@suss/adapter-ruby 0.32.0 → 0.33.1

package/dist/index.js

@@ -62,12 +62,19 @@ var OWN_BODY_TYPES = /* @__PURE__ */ new Set([
   "module",
   "singleton_class"
 ]);
+var PROGRAM_TYPE = "program";
+var MODULE_SCOPE_STOPS = /* @__PURE__ */ new Set([
+  ...OWN_BODY_TYPES,
+  "block",
+  "do_block"
+]);
 var NESTING_TYPES = /* @__PURE__ */ new Set(["class", "module"]);
 var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
-function enclosingMethod(node) {
+var LAMBDA_TYPE = "lambda";
+function enclosingDefinition(node) {
   let current = node.parent;
   while (current !== null) {
-    if (METHOD_TYPES.has(current.type)) {
+    if (METHOD_TYPES.has(current.type) || current.type === LAMBDA_TYPE) {
       return current;
     }
     current = current.parent;
@@ -341,7 +348,7 @@ import { nodeOfKey as nodeOfKey2 } from "@suss/resolution";
 import { hole as hole2, literalOf as literalOf3, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
-import { nodeOfKey } from "@suss/resolution";
+import { nodeOfKey, writtenValuesByKey } from "@suss/resolution";
 import { Evaluator, force, literalOf, text } from "@suss/values";
 
 // src/facts/resolve.ts
@@ -401,11 +408,14 @@ var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
 function resolveValues(db, keys) {
   askResolution(db, keys, "wanted", RUBY_PROGRAM);
 }
-function resolveEnvSites(db, sites) {
-  askResolution(db, sites, "wantedEnvSite", RUBY_PROGRAM);
+function resolveEnvObjects(db, objects) {
+  askResolution(db, objects, "wantedEnvObject", RUBY_PROGRAM);
 }
 function resolvedFunctions(db, key) {
-  return db.lookup("wantedResolves", 0, key).map((row) => String(row[1]));
+  return [
+    ...db.lookup("wantedResolves", 0, key),
+    ...db.lookup("wantedGivesBack", 0, key)
+  ].map((row) => String(row[1]));
 }
 function writtenValueOf(db, key) {
   resolveValues(db, [key]);
@@ -505,12 +515,15 @@ var BINDS_A_NAME = {
     PARAMETER_LIST_TYPES.map((type) => [type, parameterNames])
   )
 };
-function localNamesIn(definitionNode) {
+var DESCENDS_EVERYWHERE = /* @__PURE__ */ new Set();
+function localNamesIn(definitionNode, stops = DESCENDS_EVERYWHERE) {
   const names = /* @__PURE__ */ new Set();
   const visit = (node) => {
     BINDS_A_NAME[node.type]?.(node, names);
     for (const child of bodyStatements(node)) {
-      visit(child);
+      if (!stops.has(child.type)) {
+        visit(child);
+      }
     }
   };
   visit(definitionNode);
@@ -523,11 +536,12 @@ function spellsAName(node) {
   }
   return SPELLS_A_NAME[parent.type]?.(parent, node) === true;
 }
+var KEYWORD_LITERALS = /* @__PURE__ */ new Set(["__FILE__", "__LINE__", "__ENCODING__"]);
 function isBareMethodCall(node, locals) {
   if (node.type !== "identifier" || locals.has(node.text)) {
     return false;
   }
-  return !spellsAName(node);
+  return !KEYWORD_LITERALS.has(node.text) && !spellsAName(node);
 }
 
 // src/facts/locals.ts
@@ -678,25 +692,46 @@ function namesOfFile(tree) {
   cache.file ??= scopeNames(/* @__PURE__ */ new Set(), tree.rootNode);
   return cache.file;
 }
+function scopesAround(enclosing) {
+  const chain = [];
+  let current = enclosing;
+  while (current !== null && current.type === LAMBDA_TYPE) {
+    chain.push(current);
+    current = enclosingDefinition(current);
+  }
+  chain.push(current);
+  return chain;
+}
+var namesOfScope = (scope, node) => scope === null ? namesOfFile(node.tree) : namesOfMethod(scope);
 function ownerOfName(node, name, enclosing) {
   if (node.type === "constant") {
     return null;
   }
-  const names = enclosing === null ? namesOfFile(node.tree) : namesOfMethod(enclosing);
-  if (names.blockParams.has(name)) {
-    const block = blockDeclaring(node, name);
-    if (block !== null) {
-      return block;
+  for (const scope of scopesAround(enclosing)) {
+    const names = namesOfScope(scope, node);
+    if (names.blockParams.has(name)) {
+      const block = blockDeclaring(node, name);
+      if (block !== null) {
+        return block;
+      }
+    }
+    if (scope !== null && names.locals.has(name)) {
+      return scope;
     }
   }
-  return enclosing !== null && names.locals.has(name) ? enclosing : null;
+  return null;
 }
 function isLocalName(node, name, enclosing) {
-  const names = enclosing === null ? namesOfFile(node.tree) : namesOfMethod(enclosing);
-  if (names.blockParams.has(name) && blockDeclaring(node, name) !== null) {
-    return true;
+  for (const scope of scopesAround(enclosing)) {
+    const names = namesOfScope(scope, node);
+    if (names.blockParams.has(name) && blockDeclaring(node, name) !== null) {
+      return true;
+    }
+    if (names.locals.has(name)) {
+      return true;
+    }
   }
-  return names.locals.has(name);
+  return false;
 }
 function blockDeclaring(node, name) {
   let current = node.parent;
@@ -887,19 +922,33 @@ function calleeKeyOf(filePath, node, enclosing) {
   }
   return field(node, "receiver") === null ? nameKey(filePath, method, enclosing) : nodeId(filePath, method);
 }
+function invokedKeyOf(filePath, node, enclosing) {
+  const invoked = invokedValueOf(node);
+  return invoked === null ? null : readKey(filePath, invoked, enclosing);
+}
 function emitCall(emitter, call) {
-  add(emitter, "writtenValue", nodeId(emitter.filePath, call));
+  const callKey = nodeId(emitter.filePath, call);
+  add(emitter, "writtenValue", callKey);
+  const invoked = invokedValueOf(call);
+  if (invoked !== null) {
+    add(emitter, "call", callKey, valueKey(emitter, invoked));
+  }
+  if (!emitMessageSent(emitter, call, callKey) && invoked === null) {
+    return;
+  }
+  emitCallArguments(emitter, call, callKey);
+}
+function emitMessageSent(emitter, call, callKey) {
   const method = call.type === "identifier" ? call : field(call, "method");
   const calleeKey = calleeKeyOf(emitter.filePath, call, emitter.enclosing);
   if (method === null || calleeKey === null) {
-    return;
+    return false;
   }
-  const receiver = field(call, "receiver");
-  const callKey = nodeId(emitter.filePath, call);
   add(emitter, "call", callKey, calleeKey);
   if (!emitter.insideMethod) {
     add(emitter, "callOutsideMethod", callKey);
   }
+  const receiver = field(call, "receiver");
   if (receiver !== null) {
     add(
       emitter,
@@ -911,6 +960,21 @@ function emitCall(emitter, call) {
   } else if (emitter.selfKey !== null) {
     add(emitter, "readsProperty", calleeKey, emitter.selfKey, method.text);
   }
+  return true;
+}
+var INVOKE_METHOD = "call";
+function invokedValueOf(call) {
+  if (call.type !== "call") {
+    return null;
+  }
+  const receiver = field(call, "receiver");
+  if (receiver === null) {
+    return null;
+  }
+  const method = field(call, "method");
+  return method === null || method.text === INVOKE_METHOD ? receiver : null;
+}
+function emitCallArguments(emitter, call, callKey) {
   const args = field(call, "arguments");
   let position = 0;
   for (const argument of args === null ? [] : children(args)) {
@@ -1030,12 +1094,58 @@ function walkExpressions(node, emitter, visit, turns = []) {
     );
   }
 }
+var WRITTEN_KEY_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "integer",
+  "simple_symbol",
+  "bare_string",
+  "bare_symbol"
+]);
+function emitKeyedRead(emitter, site, container, key) {
+  if (WRITTEN_KEY_TYPES.has(key.type)) {
+    return;
+  }
+  add(
+    emitter,
+    "readsKeyed",
+    nodeId(emitter.filePath, site),
+    valueKey(emitter, container),
+    valueKey(emitter, key)
+  );
+}
+function emitKeyedElement(emitter, node) {
+  const object = field(node, "object");
+  if (object === null || isWriteTarget(node)) {
+    return;
+  }
+  const index = node.namedChildren.find(
+    (child) => child !== null && child.id !== object.id
+  );
+  if (index !== void 0) {
+    emitKeyedRead(emitter, node, object, index);
+  }
+}
+function emitKeyedFetch(emitter, call) {
+  const receiver = field(call, "receiver");
+  if (receiver === null || field(call, "method")?.text !== "fetch") {
+    return;
+  }
+  const { positional } = readCallArgs(field(call, "arguments"));
+  const key = positional[0];
+  if (key !== void 0) {
+    emitKeyedRead(emitter, call, receiver, key);
+  }
+}
 function emitExpressionFacts(emitter, node) {
   emitDynamicDefinition(emitter, node, []);
   walkExpressions(node, emitter, (child, turns) => {
     emitDynamicDefinition(emitter, child, turns);
     if (child.type === "call" || isBareCall(child, emitter.enclosing)) {
       emitCall(emitter, child);
+      emitKeyedFetch(emitter, child);
+    }
+    if (child.type === "element_reference") {
+      emitKeyedElement(emitter, child);
     }
     if (ARRAY_TYPES.has(child.type)) {
       emitArray(emitter, child);
@@ -1159,6 +1269,25 @@ function assignedValueOf(node) {
   }
   return field(node, "right");
 }
+function emitLambdasIn(emitter, body) {
+  for (const child of children(body)) {
+    if (child.type === LAMBDA_TYPE) {
+      emitMethodFacts(emitter, child);
+      continue;
+    }
+    if (OWN_BODY_TYPES.has(child.type)) {
+      continue;
+    }
+    emitLambdasIn(emitter, child);
+  }
+}
+function definitionBody(definition) {
+  const body = field(definition, "body");
+  if (body === null || definition.type !== LAMBDA_TYPE) {
+    return body;
+  }
+  return field(body, "body");
+}
 function emitMethodFacts(emitter, method) {
   const funcKey = nodeId(emitter.filePath, method);
   add(emitter, "func", funcKey);
@@ -1173,7 +1302,7 @@ function emitMethodFacts(emitter, method) {
     position += 1;
   }
   const inside = { ...emitter, enclosing: method };
-  const body = field(method, "body");
+  const body = definitionBody(method);
   if (body === null) {
     return funcKey;
   }
@@ -1205,6 +1334,7 @@ function emitMethodFacts(emitter, method) {
   }
   emitExpressionFacts(inside, body);
   emitScopeWrites(inside, method, body);
+  emitLambdasIn(inside, body);
   return funcKey;
 }
 function isConstruction(value) {
@@ -1364,12 +1494,15 @@ function emitClassFacts(emitter, cls) {
         add(emitter, "initializes", classKey, funcKey);
       }
     }
-    const methodBody = field(statement, "body");
-    if (methodBody !== null) {
-      emitInstanceStores(within, funcKey, methodBody, stored);
+    const methodBody2 = field(statement, "body");
+    if (methodBody2 !== null) {
+      emitInstanceStores(within, funcKey, methodBody2, stored);
     }
   }
   emitInstanceWrites(within, classKey, collected);
+  if (body !== null) {
+    emitLambdasIn(within, body);
+  }
   return classKey;
 }
 function emitValueFacts(db, filePath, root, bodyBlocks = NO_BODY_BLOCKS) {
@@ -1405,6 +1538,7 @@ function emitValueFacts(db, filePath, root, bodyBlocks = NO_BODY_BLOCKS) {
   walk(root);
   emitExpressionFacts(emitter, root);
   emitScopeWrites(emitter, null, root);
+  emitLambdasIn(emitter, root);
 }
 
 // src/values/lowering.ts
@@ -2424,6 +2558,24 @@ function writtenNodeOf(node, db, site) {
   const context = db === void 0 ? void 0 : contexts.get(db);
   return context === void 0 ? null : context.writtenTo(node, site);
 }
+function askWrittenValues(nodes, db) {
+  if (db === void 0 || !contexts.has(db)) {
+    return;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const file = filesByTree.get(node.tree);
+    if (file !== void 0) {
+      keys.add(readKey(file, node, enclosingDefinition(node)));
+    }
+  }
+  if (keys.size === 0) {
+    return;
+  }
+  const asked = [...keys];
+  resolveValues(db, asked);
+  writtenValuesByKey(db, asked, (more) => resolveValues(db, more));
+}
 function evaluatedValue(node, db, bindings, site) {
   const evaluator = evaluatorFor(node, db);
   if (bindings === void 0) {
@@ -2504,7 +2656,7 @@ function contextOver(db, nodes) {
       if (file === null) {
         return null;
       }
-      const key = readKey(file, node, enclosingMethod(node));
+      const key = readKey(file, node, enclosingDefinition(node));
       const answer = site === void 0 ? writtenValueOf(db, key) : writtenValueUnder(db, key, site);
       return answer === null ? null : nodeOfKey(rootsByFile, answer);
     },
@@ -2514,7 +2666,7 @@ function contextOver(db, nodes) {
       if (file === null || method === null) {
         return null;
       }
-      const key = field(call, "receiver") === null ? readKey(file, method, enclosingMethod(call)) : nodeId(file, method);
+      const key = field(call, "receiver") === null ? readKey(file, method, enclosingDefinition(call)) : nodeId(file, method);
       resolveValues(db, [key]);
       const resolved = resolvedFunctions(db, key);
       const settled = resolved.length === 1 ? resolved[0] : void 0;
@@ -2666,8 +2818,8 @@ function qualifyConstantRef(node, nesting) {
     return compoundName(node);
   }
   if (node.type === "constant") {
-    const innermost = nesting[0] ?? null;
-    return innermost === null ? node.text : `${innermost}::${node.text}`;
+    const innermost2 = nesting[0] ?? null;
+    return innermost2 === null ? node.text : `${innermost2}::${node.text}`;
   }
   return null;
 }
@@ -2724,9 +2876,9 @@ function ownIdentity(nameNode, outerNesting) {
   return { qualifiedName, bodyNesting: [qualifiedName, ...outerNesting] };
 }
 function definedName(nameNode, outerNesting) {
-  const innermost = outerNesting[0] ?? null;
-  if (nameNode.type === "scope_resolution" && innermost !== null && !nameNode.text.startsWith("::")) {
-    return `${innermost}::${nameNode.text}`;
+  const innermost2 = outerNesting[0] ?? null;
+  if (nameNode.type === "scope_resolution" && innermost2 !== null && !nameNode.text.startsWith("::")) {
+    return `${innermost2}::${nameNode.text}`;
   }
   return qualifyConstantRef(nameNode, outerNesting);
 }
@@ -3354,24 +3506,38 @@ function isCall(node, locals, inherited) {
   }
   return isBareMethodCall(node, locals) && !RAISE_NAMES2.has(node.text) && !inherited.has(node.text);
 }
-function collectCalls(node, locals, inherited, found) {
+function collectCalls(node, read, inherited, found) {
   for (const child of children2(node)) {
-    if (OWN_BODY_TYPES.has(child.type)) {
+    if (read.stops.has(child.type)) {
       continue;
     }
-    if (isCall(child, locals, inherited)) {
+    if (isCall(child, read.locals, inherited)) {
       found.push(child);
     }
-    collectCalls(child, locals, inherited, found);
+    collectCalls(child, read, inherited, found);
   }
   return found;
 }
-function bodyCalls(definitionNode, inherited = NO_INHERITED_METHODS) {
+function methodBody(definitionNode) {
   const body = field(definitionNode, "body");
   if (body === null) {
-    return [];
+    return null;
   }
-  return collectCalls(body, localNamesIn(definitionNode), inherited, []);
+  return {
+    body,
+    locals: localNamesIn(definitionNode),
+    stops: OWN_BODY_TYPES
+  };
+}
+function moduleScopeBody(root) {
+  return {
+    body: root,
+    locals: localNamesIn(root, MODULE_SCOPE_STOPS),
+    stops: MODULE_SCOPE_STOPS
+  };
+}
+function bodyCalls(read, inherited = NO_INHERITED_METHODS) {
+  return collectCalls(read.body, read, inherited, []);
 }
 function calleeText(call) {
   const receiver = field(call, "receiver");
@@ -3415,14 +3581,23 @@ function enclosingStatement(call, body) {
   return current;
 }
 function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
-  const body = field(definitionNode, "body");
-  if (body === null) {
+  const read = methodBody(definitionNode);
+  if (read === null) {
     return [];
   }
-  const calls = callsReported(
-    bodyCalls(definitionNode, inherited),
-    keepsArglessCall
+  return effectsOfBody(read, inherited, keepsArglessCall, facts);
+}
+function moduleScopeInvocationEffects(root, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
+  return effectsOfBody(
+    moduleScopeBody(root),
+    inherited,
+    keepsArglessCall,
+    facts
   );
+}
+function effectsOfBody(read, inherited, keepsArglessCall, facts) {
+  const body = read.body;
+  const calls = callsReported(bodyCalls(read, inherited), keepsArglessCall);
   if (calls.length === 0) {
     return [];
   }
@@ -3834,6 +4009,57 @@ function clientCallUnits(root, pack, pattern, options) {
   }
   return units;
 }
+function askClientCallReads(root, patterns, options) {
+  const facts = options.facts;
+  if (facts === void 0 || patterns.length === 0) {
+    return;
+  }
+  const calls = [];
+  for (const method of methodDefinitions(root)) {
+    calls.push(...callsUnder(method));
+  }
+  if (patterns.some((pattern) => (pattern.receiverBuilders ?? []).length > 0)) {
+    askWrittenValues(receiversOf(calls), facts);
+  }
+  askWrittenValues(requestArguments(calls, patterns, options), facts);
+}
+function receiversOf(calls) {
+  const found = [];
+  for (const call of calls) {
+    const receiver = field(call, "receiver");
+    if (receiver !== null) {
+      found.push(receiver);
+    }
+  }
+  return found;
+}
+function requestArguments(calls, patterns, options) {
+  const found = [];
+  for (const call of calls) {
+    const receiver = field(call, "receiver");
+    const called = field(call, "method")?.text;
+    if (receiver === null || called === void 0) {
+      continue;
+    }
+    for (const pattern of patterns) {
+      if (!isLibraryReceiver(receiver, pattern, options)) {
+        continue;
+      }
+      const argument = requestArgument(call, called, pattern);
+      if (argument !== void 0) {
+        found.push(argument);
+      }
+    }
+  }
+  return found;
+}
+function requestArgument(call, called, pattern) {
+  const args = readCallArgs(field(call, "arguments"));
+  if (pattern.verbMethodNames[called] !== void 0) {
+    return urlNodeIn(args, pattern);
+  }
+  return pattern.requestObject?.attribute === called ? args.positional[0] : void 0;
+}
 function methodDefinitions(node, found = []) {
   for (const child of node.namedChildren) {
     if (child === null) {
@@ -3958,9 +4184,11 @@ function builderCallBehind(receiver, pattern, facts) {
   return constant2 !== null && namesConstant(constant2, pattern.constantName) ? written : null;
 }
 function urlIn(args, pattern, options, site) {
+  return pathAt(urlNodeIn(args, pattern), options, site);
+}
+function urlNodeIn(args, pattern) {
   const keyword = pattern.url.keyword;
-  const written = (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[pattern.url.position];
-  return pathAt(written, options, site);
+  return (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[pattern.url.position];
 }
 function pathAt(written, options, site) {
   if (written === void 0) {
@@ -4082,11 +4310,11 @@ function namedParameters(db) {
   }
   const named2 = /* @__PURE__ */ new Map();
   namedByDb.set(db, named2);
-  const sites = db.facts("readsEnvNamed").map((row) => String(row[0]));
-  if (sites.length === 0) {
+  const objects = db.facts("environmentObject").map((row) => String(row[0]));
+  if (objects.length === 0) {
     return named2;
   }
-  resolveEnvSites(db, sites);
+  resolveEnvObjects(db, objects);
   for (const row of db.facts("wantedParamNamesEnv")) {
     const found = named2.get(String(row[0]));
     if (found === void 0) {
@@ -4097,38 +4325,44 @@ function namedParameters(db) {
   }
   return named2;
 }
-function emitEnvNameFacts(db, file, root) {
-  for (const site of envNameSites(root)) {
-    const key = nodeId(file, site.read);
-    db.add("readsEnvNamed", [
-      key,
-      readKey(file, site.name, enclosingMethod(site.name))
-    ]);
-    if (site.defaulted) {
-      db.add(ENV_DEFAULTED, [key]);
-    }
-  }
-}
-function envNameSites(root) {
-  const sites = [];
+function emitEnvFacts(db, file, root) {
   walkDescendants2(root, null, {
     at: (node) => {
+      if (isEnv(node) && handsOnward(node)) {
+        db.add("environmentObject", [
+          readKey(file, node, enclosingDefinition(node))
+        ]);
+      }
       const site = envSiteAt(node);
-      if (site !== null && stringLiteralValue(site.name) === null) {
-        sites.push(site);
+      if (site !== null && site.defaulted && stringLiteralValue(site.name) === null) {
+        db.add(ENV_DEFAULTED, [nodeId(file, site.read)]);
       }
     },
     into: () => null
   });
-  return sites;
+}
+function handsOnward(node) {
+  const parent = node.parent;
+  if (parent === null) {
+    return true;
+  }
+  if (parent.type === "element_reference" || parent.type === "call") {
+    const site = envSiteAt(parent);
+    return site === null || stringLiteralValue(site.name) === null;
+  }
+  return true;
 }
 function helperReads(calls, facts) {
   const { db, file, named: named2 } = facts;
   const callees = new NodeMap();
   for (const call of calls) {
-    const key = calleeKeyOf(file, call, enclosingMethod(call));
-    if (key !== null) {
-      callees.set(call, key);
+    const enclosing = enclosingDefinition(call);
+    const keys = [
+      calleeKeyOf(file, call, enclosing),
+      invokedKeyOf(file, call, enclosing)
+    ].filter((key) => key !== null);
+    if (keys.length > 0) {
+      callees.set(call, keys);
     }
   }
   const reads = new NodeMap();
@@ -4137,7 +4371,7 @@ function helperReads(calls, facts) {
   }
   resolveValues(
     db,
-    [...callees].map(([, callee]) => callee)
+    [...callees].flatMap(([, keys]) => keys)
   );
   for (const [call, callee] of callees) {
     const args = namingArguments(db, named2, call, callee);
@@ -4151,10 +4385,10 @@ function helperReads(calls, facts) {
   }
   return reads;
 }
-function namingArguments(db, named2, call, callee) {
+function namingArguments(db, named2, call, callees) {
   const { positional, keyword } = readCallArgs(field(call, "arguments"));
   const found = [];
-  for (const func of resolvedFunctions(db, callee)) {
+  for (const func of callees.flatMap((key) => resolvedFunctions(db, key))) {
     for (const row of db.lookup("paramOf", 0, func)) {
       const sites = named2.get(String(row[2]));
       const argument = positional[Number(row[1])];
@@ -4418,6 +4652,9 @@ function methodNamesOf(args, filter, facts) {
     const value = named2 === void 0 ? null : stringValueOf(named2, facts);
     return value === null ? [] : [value];
   }
+  return symbolArgumentNames(args, facts);
+}
+function symbolArgumentNames(args, facts) {
   return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null);
 }
 function skipsOf(statement, filterName, facts) {
@@ -4456,19 +4693,315 @@ function actionsUnder(node, facts) {
 }
 
 // src/storage.ts
-import { storageBinding } from "@suss/ir-core";
+import { storageBinding as storageBinding2 } from "@suss/ir-core";
+import { askResolution as askResolution3 } from "@suss/resolution";
+
+// src/baseClass.ts
 import { askResolution as askResolution2 } from "@suss/resolution";
-function children3(node) {
-  return node.namedChildren.filter((child) => child !== null);
+function classBehind(facts, file, constant2) {
+  const key = constant2.type === "constant" ? `${file}#${constant2.text}` : nodeId(file, constant2);
+  const bound = new Set(
+    facts.lookup("binds", 0, key).map((row) => String(row[1]))
+  );
+  return bound.size === 1 ? [...bound][0] : void 0;
+}
+function reachesBase(facts, classKey, bases) {
+  askResolution2(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
+  return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
 }
+function enclosingClassKey(node, file) {
+  let current = node.parent;
+  while (current !== null) {
+    if (NESTING_TYPES.has(current.type)) {
+      return nodeId(file, current);
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+// src/loaders.ts
 function receiverOf(node) {
   return node.type === "call" ? field(node, "receiver") : null;
 }
 function methodOf(node) {
   return field(node, "method")?.text ?? "";
 }
+function isLoader(node, loader) {
+  if (node === null) {
+    return false;
+  }
+  if (node.type === "identifier") {
+    return node.text === loader.loader;
+  }
+  return node.type === "call" && receiverOf(node) === null && methodOf(node) === loader.loader;
+}
+function loaderPick(call, loader) {
+  const method = methodOf(call);
+  const receiver = receiverOf(call);
+  if (receiver === null) {
+    return loader.shortcuts.includes(method) ? call : null;
+  }
+  if (!loader.reads.includes(method) || receiver.type !== "call") {
+    return null;
+  }
+  const picks = methodOf(receiver) === loader.pick && isLoader(receiverOf(receiver), loader);
+  return picks ? receiver : null;
+}
+function pickedSource(call, loader) {
+  const source = loader.source;
+  const pick = source === void 0 ? null : loaderPick(call, loader);
+  if (source === void 0 || pick === null || methodOf(pick) !== loader.pick) {
+    return null;
+  }
+  const args = field(pick, "arguments");
+  const given = args === null ? void 0 : args.namedChildren[source.at];
+  return given?.type === "constant" || given?.type === "scope_resolution" ? given : null;
+}
+
+// src/rawSql.ts
+import { storageBinding } from "@suss/ir-core";
+import { readSqlAccess, splitQualifiedTable, sqlFromParts } from "@suss/sql";
+import { piecesOf as piecesOf2 } from "@suss/values";
+var MOST_HOPS = 8;
+var NOWHERE = { scope: null, container: null };
+function rawSqlEffects(call, options) {
+  for (const pattern of options.patterns) {
+    const effects = patternEffects(call, pattern, options);
+    if (effects.length > 0) {
+      return effects;
+    }
+  }
+  return [];
+}
+function patternEffects(call, pattern, options) {
+  const receiver = field(call, "receiver");
+  if (receiver === null) {
+    return [];
+  }
+  const address = addressBehind(receiver, pattern, options, 0);
+  if (address === null) {
+    return [];
+  }
+  const method = field(call, "method")?.text ?? "";
+  const args = readCallArgs(field(call, "arguments"));
+  const place = pattern.statements?.[method];
+  if (place !== void 0) {
+    const statement = statementAt(
+      args,
+      place,
+      options.facts,
+      pattern.bindPlaceholder
+    );
+    return statementEffects(call, statement, address, pattern);
+  }
+  return rowCallEffects(call, args, address, pattern, options);
+}
+function statementEffects(call, statement, address, store) {
+  if (statement === null) {
+    return [];
+  }
+  return readSqlAccess(statement, { dialect: store.dialect }).map(
+    (access) => effectOf(
+      call,
+      store,
+      {
+        scope: innermost(access.qualifier) ?? address.scope,
+        container: access.table
+      },
+      {
+        kind: access.kind,
+        fields: access.fields,
+        selector: access.selector
+      }
+    )
+  );
+}
+function innermost(qualifier) {
+  return qualifier[qualifier.length - 1] ?? null;
+}
+function rowCallEffects(call, args, address, pattern, options) {
+  const method = field(call, "method")?.text ?? "";
+  const rowCall = pattern.rowCalls?.[method];
+  if (rowCall === void 0) {
+    return [];
+  }
+  const given = rowCall.container === void 0 ? null : namedTable(stringAt(args, rowCall.container, options.facts));
+  const reached = {
+    scope: given?.scope ?? address.scope,
+    container: given?.container ?? address.container
+  };
+  if (reached.container === null) {
+    return [];
+  }
+  return [
+    effectOf(call, pattern, reached, {
+      kind: rowCall.kind,
+      fields: [],
+      selector: []
+    })
+  ];
+}
+function namedTable(name) {
+  const split = name === null ? null : splitQualifiedTable(name);
+  return split === null ? null : { scope: innermost(split.qualifier), container: split.table };
+}
+function effectOf(call, store, address, access) {
+  const operation = field(call, "method")?.text ?? "";
+  return {
+    type: "interaction",
+    binding: storageBinding({
+      recognition: "ruby-raw-sql",
+      storageSystem: store.storageSystem,
+      scope: address.scope ?? store.scope ?? "default",
+      container: address.container
+    }),
+    callee: call.text,
+    interaction: {
+      class: "storage-access",
+      kind: access.kind,
+      fields: access.fields,
+      operation,
+      ...access.selector.length > 0 ? { selector: access.selector } : {}
+    }
+  };
+}
+function addressBehind(receiver, pattern, options, hops) {
+  if (hops > MOST_HOPS) {
+    return null;
+  }
+  if (receiver.type !== "call") {
+    const written = writtenNodeOf(receiver, options.facts);
+    if (written !== null && written.id !== receiver.id) {
+      return addressBehind(written, pattern, options, hops + 1);
+    }
+    return receiver.type === "identifier" && buildsOnOwnClass(receiver, receiver.text, pattern, options) ? NOWHERE : null;
+  }
+  const method = field(receiver, "method")?.text ?? "";
+  const inner = field(receiver, "receiver");
+  if (inner === null) {
+    return buildsOnOwnClass(receiver, method, pattern, options) ? NOWHERE : null;
+  }
+  if (namesConstant2(inner, pattern.constantName) || namesSubclass(inner, pattern, options)) {
+    return pattern.clientBuilders.includes(method) ? NOWHERE : null;
+  }
+  const addressing = pattern.addressing?.[method];
+  if (addressing === void 0 || inner === null) {
+    return null;
+  }
+  const behind = addressBehind(inner, pattern, options, hops + 1);
+  if (behind === null) {
+    return null;
+  }
+  const named2 = stringAt(
+    readCallArgs(field(receiver, "arguments")),
+    addressing,
+    options.facts
+  );
+  if (addressing.says === "scope") {
+    return { scope: named2 ?? behind.scope, container: behind.container };
+  }
+  const table = namedTable(named2);
+  return {
+    scope: table?.scope ?? behind.scope,
+    container: table?.container ?? behind.container
+  };
+}
+function namesConstant2(receiver, constantName2) {
+  if (receiver.type === "constant") {
+    return receiver.text === constantName2;
+  }
+  return receiver.type === "scope_resolution" && compoundName(receiver) === constantName2;
+}
+function namesSubclass(receiver, pattern, options) {
+  const bases = pattern.baseClasses ?? [];
+  const facts = options.facts;
+  const file = options.file;
+  if (bases.length === 0 || facts === void 0 || file === void 0 || receiver.type !== "constant" && receiver.type !== "scope_resolution") {
+    return false;
+  }
+  const classKey = classBehind(facts, file, receiver);
+  return classKey !== void 0 && reachesBase(facts, classKey, bases);
+}
+function buildsOnOwnClass(node, method, pattern, options) {
+  const bases = pattern.baseClasses ?? [];
+  const facts = options.facts;
+  const file = options.file;
+  if (bases.length === 0 || facts === void 0 || file === void 0 || !pattern.clientBuilders.includes(method)) {
+    return false;
+  }
+  const classKey = enclosingClassKey(node, file);
+  return classKey !== null && reachesBase(facts, classKey, bases);
+}
+function argumentAt(args, place) {
+  const keyword = place.keyword;
+  return (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[place.at];
+}
+function stringAt(args, place, facts) {
+  const written = argumentAt(args, place);
+  if (written === void 0) {
+    return null;
+  }
+  const pieces = piecesOf2(evaluatedValue(written, facts));
+  const only = pieces.length === 1 ? pieces[0] : void 0;
+  if (only === void 0 || only.kind !== "text" || only.options.length !== 1) {
+    return null;
+  }
+  return only.options[0] ?? null;
+}
+function statementAt(args, place, facts, bindPlaceholder) {
+  const written = argumentAt(args, place);
+  if (written === void 0) {
+    return null;
+  }
+  const parts = literalParts(statementValue(evaluatedValue(written, facts)));
+  if (parts === null) {
+    return null;
+  }
+  const statement = sqlFromParts(bindsSplit(parts, bindPlaceholder));
+  return statement.trim() === "" ? null : statement;
+}
+function bindsSplit(parts, bindPlaceholder) {
+  if (bindPlaceholder === void 0 || bindPlaceholder === "") {
+    return [...parts];
+  }
+  return parts.flatMap((part) => part.split(bindPlaceholder));
+}
+function statementValue(value) {
+  if (value.kind !== "sequence") {
+    return value;
+  }
+  const first = value.items[0];
+  return first === void 0 ? value : first.value;
+}
+function literalParts(value) {
+  if (value.kind !== "string") {
+    return null;
+  }
+  const parts = [""];
+  for (const piece of value.pieces) {
+    const only = piece.kind === "text" ? piece.options : [];
+    if (only.length === 1) {
+      parts[parts.length - 1] += only[0] ?? "";
+      continue;
+    }
+    parts.push("");
+  }
+  return parts;
+}
+
+// src/storage.ts
+function children3(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function receiverOf2(node) {
+  return node.type === "call" ? field(node, "receiver") : null;
+}
+function methodOf2(node) {
+  return field(node, "method")?.text ?? "";
+}
 function rootConstant(node) {
-  const receiver = receiverOf(node);
+  const receiver = receiverOf2(node);
   if (receiver === null) {
     return null;
   }
@@ -4483,17 +5016,6 @@ function isConstant(node) {
 function constantName(constant2) {
   return constant2.type === "constant" ? constant2.text : compoundName(constant2);
 }
-function reachesBase(facts, classKey, bases) {
-  askResolution2(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
-  return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
-}
-function 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 modelPattern(constant2, file, options) {
   const classKey = classBehind(options.facts, file, constant2);
   if (classKey === void 0) {
@@ -4508,7 +5030,7 @@ function chainLinks(call) {
   let current = call;
   while (current !== null && current.type === "call") {
     links.push(current);
-    current = receiverOf(current);
+    current = receiverOf2(current);
   }
   return links;
 }
@@ -4521,9 +5043,17 @@ function kindOfCall(pattern, method) {
   }
   return void 0;
 }
+function libraryCallOf(pattern, method) {
+  const place = pattern.statements?.[method];
+  if (place !== void 0) {
+    return { how: "statement", place };
+  }
+  const kind = kindOfCall(pattern, method);
+  return kind === void 0 ? void 0 : { how: "rows", kind };
+}
 function someLibraryDefines(options, method) {
   return options.patterns.some(
-    (pattern) => kindOfCall(pattern, method) !== void 0
+    (pattern) => libraryCallOf(pattern, method) !== void 0
   );
 }
 function argumentsOf2(call) {
@@ -4558,7 +5088,7 @@ function hasPositionalArgument(call, facts) {
   );
 }
 function columnsAskedFor(call, pattern, facts) {
-  if (!(pattern.columnArguments ?? []).includes(methodOf(call))) {
+  if (!(pattern.columnArguments ?? []).includes(methodOf2(call))) {
     return [];
   }
   return argumentsOf2(call).map((argument) => stringValueOf(argument, facts)).filter((column) => column !== null);
@@ -4568,14 +5098,14 @@ function primaryKeySelector(call, pattern, facts) {
   if (byPrimaryKey === void 0) {
     return [];
   }
-  const picks = byPrimaryKey.methods.includes(methodOf(call)) && hasPositionalArgument(call, facts);
+  const picks = byPrimaryKey.methods.includes(methodOf2(call)) && hasPositionalArgument(call, facts);
   return picks ? [byPrimaryKey.column] : [];
 }
 function selectorOf(call, pattern, facts) {
   const picked = [];
   for (const link of chainLinks(call)) {
     picked.push(...primaryKeySelector(link, pattern, facts));
-    if (pattern.reads.includes(methodOf(link))) {
+    if (pattern.reads.includes(methodOf2(link))) {
       picked.push(...keywordKeys(link, facts));
     }
   }
@@ -4592,10 +5122,10 @@ function fieldsOf(call, pattern, kind, facts) {
   ];
 }
 function storageEffect(call, container, pattern, kind, selector, fields) {
-  const operation = methodOf(call);
+  const operation = methodOf2(call);
   return {
     type: "interaction",
-    binding: storageBinding({
+    binding: storageBinding2({
       recognition: "ruby-storage",
       storageSystem: pattern.storageSystem,
       scope: "default",
@@ -4612,7 +5142,7 @@ function storageEffect(call, container, pattern, kind, selector, fields) {
   };
 }
 function classSettledOn(facts, key) {
-  askResolution2(facts, [key], "wanted", RUBY_PROGRAM);
+  askResolution3(facts, [key], "wanted", RUBY_PROGRAM);
   const objects = new Set(
     facts.lookup("wantedObjectOf", 0, key).map((row) => String(row[1]))
   );
@@ -4644,7 +5174,7 @@ function receiverClass(call, file, options, enclosing) {
   if (constant2 !== null) {
     return constantReceiver(constant2, file, options.facts);
   }
-  const receiver = receiverOf(call);
+  const receiver = receiverOf2(call);
   if (receiver === null) {
     return void 0;
   }
@@ -4652,60 +5182,91 @@ function receiverClass(call, file, options, enclosing) {
 }
 function libraryCallIn(call, options) {
   return chainLinks(call).find(
-    (link) => someLibraryDefines(options, methodOf(link))
+    (link) => someLibraryDefines(options, methodOf2(link))
   ) ?? null;
 }
+function modelStatementEffects(call, place, pattern, options) {
+  const args = readCallArgs(field(call, "arguments"));
+  return statementEffects(
+    call,
+    statementAt(args, place, options.facts, pattern.bindPlaceholder),
+    NOWHERE,
+    { storageSystem: pattern.storageSystem, dialect: pattern.storageSystem }
+  );
+}
+function callbacksRunBy(facts, classKey, pattern, writeMethod) {
+  const events = pattern.callbacks?.eventOf[writeMethod] ?? [];
+  if (events.length === 0) {
+    return [];
+  }
+  askResolution3(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
+  const found = /* @__PURE__ */ new Map();
+  for (const row of facts.lookup("wantedCallbackMethod", 0, classKey)) {
+    if (events.includes(String(row[1]))) {
+      const key = String(row[3]);
+      found.set(key, { name: String(row[2]), key });
+    }
+  }
+  return [...found.values()];
+}
+function callbackEffect(callback) {
+  return {
+    type: "invocation",
+    callee: callback.name,
+    args: [],
+    async: false
+  };
+}
 function modelCallEffects(call, file, options, enclosing) {
   const worked = libraryCallIn(call, options);
   if (worked === null) {
     return [];
   }
-  const method = methodOf(worked);
+  const method = methodOf2(worked);
   const target = receiverClass(worked, file, options, enclosing);
   if (target === void 0) {
     return [];
   }
   for (const pattern of options.patterns) {
-    const kind = kindOfCall(pattern, method);
-    if (kind === void 0 || !reachesBase(options.facts, target.classKey, pattern.baseClasses)) {
+    const library = libraryCallOf(pattern, method);
+    if (library === void 0 || !reachesBase(options.facts, target.classKey, pattern.baseClasses)) {
       continue;
     }
     if (projectDeclares(options.facts, target.classKey, method)) {
       return [];
     }
+    if (library.how === "statement") {
+      return modelStatementEffects(worked, library.place, pattern, options);
+    }
+    const ran = library.kind === "write" ? callbacksRunBy(options.facts, target.classKey, pattern, method) : [];
     return [
       storageEffect(
         worked,
         target.container,
         pattern,
-        kind,
+        library.kind,
         selectorOf(worked, pattern, options.facts),
-        fieldsOf(worked, pattern, kind, options.facts)
-      )
+        fieldsOf(worked, pattern, library.kind, options.facts)
+      ),
+      ...ran.map(callbackEffect)
     ];
   }
   return [];
 }
-function isLoader(node, loader) {
-  if (node === null) {
-    return false;
-  }
-  if (node.type === "identifier") {
-    return node.text === loader.loader;
-  }
-  return node.type === "call" && receiverOf(node) === null && methodOf(node) === loader.loader;
-}
-function loaderPick(call, loader) {
-  const method = methodOf(call);
-  const receiver = receiverOf(call);
-  if (receiver === null) {
-    return loader.shortcuts.includes(method) ? call : null;
+function callbacksReached(call, file, options, enclosing = null) {
+  const worked = libraryCallIn(call, options);
+  const target = worked === null ? void 0 : receiverClass(worked, file, options, enclosing);
+  if (worked === null || target === void 0) {
+    return [];
   }
-  if (!loader.reads.includes(method) || receiver.type !== "call") {
-    return null;
+  const method = methodOf2(worked);
+  for (const pattern of options.patterns) {
+    if (libraryCallOf(pattern, method)?.how !== "rows" || kindOfCall(pattern, method) !== "write" || !reachesBase(options.facts, target.classKey, pattern.baseClasses) || projectDeclares(options.facts, target.classKey, method)) {
+      continue;
+    }
+    return callbacksRunBy(options.facts, target.classKey, pattern, method);
   }
-  const picks = methodOf(receiver) === loader.pick && isLoader(receiverOf(receiver), loader);
-  return picks ? receiver : null;
+  return [];
 }
 function loaderCallEffects(call, file, options) {
   const effects = [];
@@ -4731,10 +5292,24 @@ function loaderCallEffects(call, file, options) {
 }
 function effectsOfCall(call, file, options, enclosing) {
   const onModel = modelCallEffects(call, file, options, enclosing);
-  return onModel.length > 0 ? onModel : loaderCallEffects(call, file, options);
+  if (onModel.length > 0) {
+    return onModel;
+  }
+  const throughLoader = loaderCallEffects(call, file, options);
+  if (throughLoader.length > 0) {
+    return throughLoader;
+  }
+  return rawSqlEffects(call, {
+    facts: options.facts,
+    patterns: options.rawSql ?? [],
+    file
+  });
 }
 function storageClaims(call, file, options, enclosing = null) {
-  return options.patterns.length > 0 && effectsOfCall(call, file, options, enclosing).length > 0;
+  return saysAnything(options) && effectsOfCall(call, file, options, enclosing).length > 0;
+}
+function saysAnything(options) {
+  return options.patterns.length > 0 || (options.rawSql ?? []).length > 0;
 }
 function receiverKeysToAsk(chains, file, options, enclosing) {
   const keys = [];
@@ -4743,7 +5318,7 @@ function receiverKeysToAsk(chains, file, options, enclosing) {
     if (worked === null || rootConstant(worked) !== null) {
       continue;
     }
-    const receiver = receiverOf(worked);
+    const receiver = receiverOf2(worked);
     if (receiver !== null) {
       keys.push(readKey(file, receiver, enclosing));
     }
@@ -4751,18 +5326,18 @@ function receiverKeysToAsk(chains, file, options, enclosing) {
   return keys;
 }
 function storageEffects(calls, file, options, enclosing = null) {
-  if (options.patterns.length === 0) {
+  if (!saysAnything(options)) {
     return [];
   }
   const partOfOne = /* @__PURE__ */ new Set();
   for (const call of calls) {
-    const receiver = receiverOf(call);
+    const receiver = receiverOf2(call);
     if (receiver !== null) {
       partOfOne.add(receiver.id);
     }
   }
   const chains = calls.filter((call) => !partOfOne.has(call.id));
-  askResolution2(
+  askResolution3(
     options.facts,
     receiverKeysToAsk(chains, file, options, enclosing),
     "wanted",
@@ -4887,14 +5462,18 @@ async function discoverUnits(root, options) {
     file: options.absoluteFile ?? options.filePath
   }));
   const units = [];
+  const clientOptions = {
+    filePath: options.filePath,
+    ...options.facts === void 0 ? {} : { facts: options.facts }
+  };
+  askClientCallReads(
+    root,
+    options.packs.flatMap((pack) => pack.clients ?? []),
+    clientOptions
+  );
   for (const pack of options.packs) {
     for (const pattern of pack.clients ?? []) {
-      units.push(
-        ...clientCallUnits(root, pack, pattern, {
-          filePath: options.filePath,
-          ...options.facts === void 0 ? {} : { facts: options.facts }
-        })
-      );
+      units.push(...clientCallUnits(root, pack, pattern, clientOptions));
     }
   }
   for (const info of classes) {
@@ -6008,6 +6587,47 @@ function buildRubyExtractionReport(args) {
   });
 }
 
+// src/facts/callbacks.ts
+function callbacksIn(patterns) {
+  return patterns.flatMap(
+    (pattern) => pattern.callbacks === void 0 ? [] : [pattern.callbacks]
+  );
+}
+function emitClassCallbacks(db, file, classNode, declared) {
+  const body = field(classNode, "body");
+  if (body === null || declared.length === 0) {
+    return;
+  }
+  const classKey = nodeId(file, classNode);
+  for (const statement of runStatements(body)) {
+    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+      continue;
+    }
+    const called = field(statement, "method")?.text ?? "";
+    const args = readCallArgs(field(statement, "arguments"));
+    for (const callbacks of declared) {
+      const events = eventsOf(args, called, callbacks, db);
+      for (const event of events) {
+        for (const method of symbolArgumentNames(args, db)) {
+          db.add("classCallback", [classKey, event, method]);
+        }
+      }
+    }
+  }
+}
+function eventsOf(args, called, callbacks, db) {
+  const covered = callbacks.registeredBy[called];
+  if (covered === void 0) {
+    return [];
+  }
+  const written = args.keyword[callbacks.eventKeyword];
+  const narrowed = written === void 0 ? null : stringValueOf(written, db);
+  if (narrowed === null) {
+    return covered;
+  }
+  return covered.filter((event) => event === narrowed);
+}
+
 // src/facts.ts
 import path3 from "path";
 import { SKIP_CHILDREN as SKIP_CHILDREN3, walkDescendants as walkDescendants3 } from "@suss/extractor";
@@ -6124,6 +6744,10 @@ function calleeSpellings(calls, ctx) {
   };
 }
 function resolveCallee(call, site, ctx, read) {
+  const throughLoader = loaderSourceCallee(call, site, ctx);
+  if (throughLoader !== null) {
+    return throughLoader;
+  }
   const spelling = read?.spellingOf.get(call.id) ?? spellingFor(call, site);
   if (spelling.kind === "stopped") {
     return spelling;
@@ -6133,6 +6757,21 @@ function resolveCallee(call, site, ctx, read) {
   }
   return asCallee(spelling, outcomeFor(spelling.key, ctx, read), site, ctx);
 }
+function loaderSourceCallee(call, site, ctx) {
+  for (const loader of ctx.loaders) {
+    const constant2 = pickedSource(call, loader);
+    const source = loader.source;
+    if (constant2 === null || source === void 0) {
+      continue;
+    }
+    const classKey = classBehind(ctx.facts, site.file, constant2);
+    const qualifiedName = classKey === void 0 ? void 0 : ctx.classNames.get(classKey);
+    if (qualifiedName !== void 0) {
+      return methodOnAncestryOf(qualifiedName, source.method, ctx);
+    }
+  }
+  return null;
+}
 function outcomeFor(key, ctx, read) {
   return read?.outcomes.get(key) ?? calleeOutcomeOf(ctx.facts, key, RUBY_PROGRAM);
 }
@@ -6314,6 +6953,7 @@ async function reachedFunctions(seeds, options) {
   const parameterCallsByKey = /* @__PURE__ */ new Map();
   const propertyReadsByKey = /* @__PURE__ */ new Map();
   const passedPositions = /* @__PURE__ */ new Set();
+  const followedKeys = /* @__PURE__ */ new Set();
   for (const seed of seeds) {
     seedKeys.add(seed.key);
     functionByKey.set(seed.key, {
@@ -6361,6 +7001,9 @@ async function reachedFunctions(seeds, options) {
       for (const position of scan.passedPositions) {
         passedPositions.add(position);
       }
+      if (scan.followed.length > 0) {
+        followedKeys.add(key);
+      }
       for (const target of scan.followed) {
         const calleeKey = keyOf(target);
         if (!functionByKey.has(calleeKey)) {
@@ -6397,7 +7040,8 @@ async function reachedFunctions(seeds, options) {
     argTargetsByKey,
     parameterCallsByKey,
     propertyReadsByKey,
-    passedPositions
+    passedPositions,
+    followedKeys
   };
 }
 function keyOf(target) {
@@ -6436,13 +7080,9 @@ function methodReferenceSymbol(node) {
   return argChildren.length === 1 && argChildren[0]?.type === "simple_symbol" ? argChildren[0] : null;
 }
 function bodyOf2(source, options) {
-  const site = {
-    file: source.file,
-    method: source.node,
-    owner: keyOf(source),
-    enclosingQualifiedName: source.enclosingQualifiedName
-  };
-  const written = field(source.node, "body") === null ? [] : bodyCalls(source.node, options.inheritedMethods);
+  const site = siteOf2(source);
+  const read = readableBodyOf(source.node);
+  const written = read === null ? [] : bodyCalls(read, options.inheritedMethods);
   const calls = callsReported(
     written,
     (call) => mightReadAsACall(call, site, options.context)
@@ -6454,6 +7094,17 @@ function bodyOf2(source, options) {
     written: calls.map((call) => ({ call, site }))
   };
 }
+function readableBodyOf(node) {
+  return node.type === PROGRAM_TYPE ? moduleScopeBody(node) : methodBody(node);
+}
+function siteOf2(source) {
+  return {
+    file: source.file,
+    method: source.node.type === PROGRAM_TYPE ? null : source.node,
+    owner: keyOf(source),
+    enclosingQualifiedName: source.enclosingQualifiedName
+  };
+}
 function callsMade(asked, site, ctx, spellings) {
   return asked.filter(
     (call) => !isArglessReceiverCall(call) || readsAsACall(call, site, ctx, spellings)
@@ -6461,7 +7112,7 @@ function callsMade(asked, site, ctx, spellings) {
 }
 function scanBody(source, ctx, options, read) {
   const displayPathOf = options.displayPathOf;
-  if (field(source.node, "body") === null) {
+  if (readableBodyOf(source.node) === null) {
     return EMPTY_SCAN;
   }
   const site = read.site;
@@ -6504,9 +7155,34 @@ function scanBody(source, ctx, options, read) {
       }
     }
   };
+  const followCallback = (name, key) => {
+    const target = ctx.definitions.get(key);
+    if (target === void 0) {
+      return;
+    }
+    const targetKey = keyOf(target);
+    if (!seen.has(targetKey)) {
+      seen.add(targetKey);
+      followed2.push(target);
+    }
+    placements.place(name, {
+      file: displayPathOf(target.file),
+      span: spanOf(target.node)
+    });
+  };
   for (const call of calls) {
     const callee = calleeText(call);
     const outcome = resolveCallee(call, site, ctx, read.spellings);
+    if (options.storage !== void 0) {
+      for (const callback of callbacksReached(
+        call,
+        source.file,
+        options.storage,
+        site.method
+      )) {
+        followCallback(callback.name, callback.key);
+      }
+    }
     const placed = outcome.kind === "followed" ? {
       file: displayPathOf(outcome.target.file),
       span: spanOf(outcome.target.node)
@@ -6639,7 +7315,7 @@ function parameterName(param) {
 
 // src/reach/context.ts
 var METHOD_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
-async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dynamicNames = /* @__PURE__ */ new Map()) {
+async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dynamicNames = /* @__PURE__ */ new Map(), loaders = []) {
   const blocksByQualifiedName = /* @__PURE__ */ new Map();
   const classes = [];
   const classNames = /* @__PURE__ */ new Map();
@@ -6715,7 +7391,8 @@ async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dyna
     classNames,
     definitions,
     bodyBlocks,
-    dynamicNames
+    dynamicNames,
+    loaders
   };
 }
 function namedChildren(node) {
@@ -6783,7 +7460,7 @@ function factsForFile(options) {
   const db = new Database2();
   const bodyBlocks = bodyBlocksIn(options.packs);
   emitValueFacts(db, options.file, options.root, bodyBlocks);
-  emitEnvNameFacts(db, options.file, options.root);
+  emitEnvFacts(db, options.file, options.root);
   emitConstantBindings(db, [
     collectFileConstants(
       options.file,
@@ -6800,6 +7477,19 @@ function factsForFile(options) {
   addPackWords(db, packWordsOf(options.packs));
   return db;
 }
+function moduleInitUnit(options) {
+  const raw = moduleInitStructure({
+    name: options.name,
+    file: options.file,
+    range: options.range,
+    effects: options.effects
+  });
+  const branch = raw.branches[0];
+  if (branch !== void 0) {
+    branch.effects = options.calls;
+  }
+  return raw;
+}
 function alreadyDiscovered(seen, raw) {
   const reported = raw.identity.exportPath?.join(".") ?? raw.identity.name;
   const boundary = raw.boundaryBinding === null ? "" : boundaryKey(raw.boundaryBinding) ?? "";
@@ -6855,7 +7545,7 @@ async function extractRubyProject(options) {
       }
       parsed.push({ file, root });
       emitValueFacts(db, file, root, bodyBlocks);
-      emitEnvNameFacts(db, file, root);
+      emitEnvFacts(db, file, root);
       for (const [key, method] of methodDefinitionsIn(file, root)) {
         definitions.set(key, method);
       }
@@ -6872,6 +7562,15 @@ async function extractRubyProject(options) {
     }
     bindEvaluator(db, { files: parsed, definitions });
     addPackWords(db, packWordsOf(options.packs));
+    const callbacks = callbacksIn(
+      options.packs.flatMap((pack) => pack.storage ?? [])
+    );
+    for (const { file, root } of parsed) {
+      walkDefinitions(
+        root,
+        (info) => emitClassCallbacks(db, file, info.node, callbacks)
+      );
+    }
     return readDynamicNames(
       db,
       new Map(parsed.map(({ file, root }) => [file, root]))
@@ -6879,11 +7578,17 @@ async function extractRubyProject(options) {
   });
   const storagePatterns = options.packs.flatMap((pack) => pack.storage ?? []);
   const loaderPatterns = options.packs.flatMap((pack) => pack.loaders ?? []);
-  const storage = storagePatterns.length > 0 ? { facts: db, patterns: storagePatterns, loaders: loaderPatterns } : void 0;
+  const rawSqlPatterns = options.packs.flatMap((pack) => pack.rawSql ?? []);
+  const storage = storagePatterns.length > 0 || rawSqlPatterns.length > 0 ? {
+    facts: db,
+    patterns: storagePatterns,
+    loaders: loaderPatterns,
+    rawSql: rawSqlPatterns
+  } : void 0;
   const inheritedMethods = inheritedMethodsIn(options.packs);
   const reachContext = await timer.timeAsync(
     "discover",
-    () => buildReachContext(parsed, db, bodyBlocks, dynamicNames)
+    () => buildReachContext(parsed, db, bodyBlocks, dynamicNames, loaderPatterns)
   );
   const displayPathOf = (file) => options.workspaceRoot !== void 0 ? path4.relative(options.workspaceRoot, file) : file;
   const seeds = [];
@@ -6933,26 +7638,34 @@ async function extractRubyProject(options) {
         });
       }
     }
-    const loadTimeReads = timer.time(
-      "discover",
-      () => envReadEffects(root, { db, file })
-    );
-    if (loadTimeReads.length > 0) {
-      const summary = timer.time(
-        "summarize",
-        () => assembleSummary2(
-          moduleInitStructure({
-            name: path4.basename(displayPath),
-            file: displayPath,
-            range: rangeOf(root),
-            effects: loadTimeReads
-          }),
-          { gapHandling: "permissive" }
-        )
-      );
-      summary.confidence = { source: "inferred_static", level: "low" };
-      found.push({ summary });
-    }
+    const moduleKey = nodeId(file, root);
+    seedKeys.add(moduleKey);
+    seeds.push({
+      key: moduleKey,
+      file,
+      node: root,
+      enclosingQualifiedName: null
+    });
+    const loadTime = timer.time("discover", () => ({
+      reads: envReadEffects(root, { db, file }),
+      calls: moduleScopeInvocationEffects(
+        root,
+        inheritedMethods,
+        EVERY_ARGLESS_CALL,
+        db
+      )
+    }));
+    found.push({
+      raw: moduleInitUnit({
+        name: path4.basename(displayPath),
+        file: displayPath,
+        range: rangeOf(root),
+        effects: loadTime.reads,
+        calls: loadTime.calls
+      }),
+      seedKey: moduleKey,
+      onlyIfItReaches: loadTime.reads.length === 0
+    });
   }
   for (const pack of options.packs) {
     for (const pattern of pack.discovery) {
@@ -6990,6 +7703,9 @@ async function extractRubyProject(options) {
       continue;
     }
     const { raw, seedKey } = entry;
+    if (entry.onlyIfItReaches === true && (seedKey === null || !reached.followedKeys.has(seedKey))) {
+      continue;
+    }
     if (seedKey !== null) {
       dropPropertyReads(raw, reached.propertyReadsByKey.get(seedKey));
     }
@@ -7137,7 +7853,7 @@ function width(node) {
   return node.endIndex - node.startIndex;
 }
 function askedKey(value) {
-  const enclosing = enclosingMethod(value.node);
+  const enclosing = enclosingDefinition(value.node);
   return calleeKeyOf(value.file, value.node, enclosing) ?? readKey(value.file, value.node, enclosing);
 }
 var RubyWhySession = class {
@@ -7352,6 +8068,8 @@ export {
   resolveConstantFile,
   rubyStubEvidence,
   runStatements,
+  storageClaims,
+  storageEffects,
   stringLiteralValue,
   stringValueOf,
   symbolValue,