@suss/adapter-ruby 0.31.2 → 0.33.0

package/dist/index.js

@@ -62,7 +62,25 @@ 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"]);
+var LAMBDA_TYPE = "lambda";
+function enclosingDefinition(node) {
+  let current = node.parent;
+  while (current !== null) {
+    if (METHOD_TYPES.has(current.type) || current.type === LAMBDA_TYPE) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
 var INCLUDE_CALL = "include";
 var PREPEND_CALL = "prepend";
 var ARGUMENT_LIST_TYPE = "argument_list";
@@ -330,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
@@ -390,8 +408,14 @@ var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
 function resolveValues(db, keys) {
   askResolution(db, keys, "wanted", RUBY_PROGRAM);
 }
+function resolveEnvObjects(db, objects) {
+  askResolution(db, objects, "wantedEnvObject", RUBY_PROGRAM);
+}
 function resolvedFunctions(db, key) {
-  return db.facts("wantedResolves").filter((row) => String(row[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]);
@@ -491,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);
@@ -509,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
@@ -664,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;
@@ -873,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,
@@ -897,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)) {
@@ -1016,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);
@@ -1145,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);
@@ -1159,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;
   }
@@ -1191,6 +1334,7 @@ function emitMethodFacts(emitter, method) {
   }
   emitExpressionFacts(inside, body);
   emitScopeWrites(inside, method, body);
+  emitLambdasIn(inside, body);
   return funcKey;
 }
 function isConstruction(value) {
@@ -1270,7 +1414,6 @@ function emitCandidates(emitter, key, group) {
     add(emitter, "writesAllStated", key);
   }
 }
-var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 var INITIALIZE_METHOD = "initialize";
 function receiverKeyOf(filePath, method, classKey) {
   return method.type === "singleton_method" ? classKey : `${nodeId(filePath, method)}#self`;
@@ -1318,7 +1461,7 @@ function emitClassFacts(emitter, cls) {
           left.text,
           valueKey(emitter, right)
         );
-        emitExpressionFacts(emitter, statement);
+        emitExpressionFacts(within, statement);
       }
       continue;
     }
@@ -1351,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) {
@@ -1392,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
@@ -2399,7 +2546,6 @@ var evaluators = /* @__PURE__ */ new WeakMap();
 var contexts = /* @__PURE__ */ new WeakMap();
 var withoutFacts = /* @__PURE__ */ new WeakMap();
 var filesByTree = /* @__PURE__ */ new WeakMap();
-var METHOD_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 function bindEvaluator(db, nodes) {
   for (const entry of nodes.files) {
     filesByTree.set(entry.root.tree, entry.file);
@@ -2412,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) {
@@ -2453,7 +2617,7 @@ function stringValueOf(node, db, bindings) {
 function methodDefinitionsIn(file, root) {
   const found = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (METHOD_TYPES3.has(node.type)) {
+    if (METHOD_TYPES.has(node.type)) {
       found.set(nodeId(file, node), node);
     }
     for (const child of node.namedChildren) {
@@ -2478,16 +2642,6 @@ function evaluatorFor(node, db) {
   }
   return local;
 }
-function enclosingMethod(node) {
-  let current = node.parent;
-  while (current !== null) {
-    if (METHOD_TYPES3.has(current.type)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
 function contextOver(db, nodes) {
   const filesByRoot = /* @__PURE__ */ new Map();
   const rootsByFile = /* @__PURE__ */ new Map();
@@ -2502,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);
     },
@@ -2512,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;
@@ -2664,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;
 }
@@ -2722,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);
 }
@@ -3352,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");
@@ -3413,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 [];
   }
@@ -3832,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) {
@@ -3956,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) {
@@ -4035,19 +4265,161 @@ function returnBranch(range, effects) {
 import { runtimeConfigBinding } from "@suss/behavioral-ir";
 import { SKIP_CHILDREN as SKIP_CHILDREN2, walkDescendants as walkDescendants2 } from "@suss/extractor";
 var RUBY_ENV_RECOGNITION = "ruby-env";
+var ENV_DEFAULTED = "rbEnvDefaulted";
 var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
-function envReadEffects(root) {
-  const effects = [];
+function envReadEffects(root, facts) {
+  const helpers = helperFactsOf(facts);
+  const slots = [];
   walkDescendants2(root, null, {
     at: (node) => {
       const read = envReadAt(node);
       if (read !== null) {
-        effects.push(configReadEffect(read));
+        slots.push({ read });
+        return;
+      }
+      if (helpers !== null && node.type === "call") {
+        slots.push({ call: node });
       }
     },
     into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? SKIP_CHILDREN2 : null
   });
-  return effects;
+  const calls = slots.flatMap((slot) => "call" in slot ? [slot.call] : []);
+  const throughHelpers = helpers === null ? new NodeMap() : helperReads(calls, helpers);
+  return slots.flatMap((slot) => {
+    if ("read" in slot) {
+      return [configReadEffect(slot.read)];
+    }
+    return (throughHelpers.get(slot.call) ?? []).map(configReadEffect);
+  });
+}
+function helperFactsOf(facts) {
+  if (facts === void 0) {
+    return null;
+  }
+  const named2 = namedParameters(facts.db);
+  if (named2.size === 0) {
+    return null;
+  }
+  return { ...facts, named: named2 };
+}
+var namedByDb = /* @__PURE__ */ new WeakMap();
+function namedParameters(db) {
+  const memo = namedByDb.get(db);
+  if (memo !== void 0) {
+    return memo;
+  }
+  const named2 = /* @__PURE__ */ new Map();
+  namedByDb.set(db, named2);
+  const objects = db.facts("environmentObject").map((row) => String(row[0]));
+  if (objects.length === 0) {
+    return named2;
+  }
+  resolveEnvObjects(db, objects);
+  for (const row of db.facts("wantedParamNamesEnv")) {
+    const found = named2.get(String(row[0]));
+    if (found === void 0) {
+      named2.set(String(row[0]), [String(row[1])]);
+      continue;
+    }
+    found.push(String(row[1]));
+  }
+  return named2;
+}
+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 && site.defaulted && stringLiteralValue(site.name) === null) {
+        db.add(ENV_DEFAULTED, [nodeId(file, site.read)]);
+      }
+    },
+    into: () => null
+  });
+}
+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 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();
+  if (callees.size === 0) {
+    return reads;
+  }
+  resolveValues(
+    db,
+    [...callees].flatMap(([, keys]) => keys)
+  );
+  for (const [call, callee] of callees) {
+    const args = namingArguments(db, named2, call, callee);
+    if (args.length === 0) {
+      continue;
+    }
+    const found = readsAtCall(db, call, args);
+    if (found.length > 0) {
+      reads.set(call, found);
+    }
+  }
+  return reads;
+}
+function namingArguments(db, named2, call, callees) {
+  const { positional, keyword } = readCallArgs(field(call, "arguments"));
+  const found = [];
+  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])];
+      if (sites !== void 0 && argument !== void 0) {
+        found.push({ sites, argument });
+      }
+    }
+    for (const row of db.lookup("paramNamed", 0, func)) {
+      const sites = named2.get(String(row[2]));
+      const argument = keyword[String(row[1])];
+      if (sites !== void 0 && argument !== void 0) {
+        found.push({ sites, argument });
+      }
+    }
+  }
+  return found;
+}
+function readsAtCall(db, call, args) {
+  const defaultedAtCall = isDefaultedAt(call);
+  const byName = /* @__PURE__ */ new Map();
+  for (const { sites, argument } of args) {
+    const name = stringLiteralValue(argument) ?? stringValueOf(argument, db);
+    if (name === null) {
+      continue;
+    }
+    for (const site of sites) {
+      const defaulted = defaultedAtCall || db.lookup(ENV_DEFAULTED, 0, site).length > 0;
+      byName.set(name, (byName.get(name) ?? true) && defaulted);
+    }
+  }
+  return [...byName].map(([name, defaulted]) => ({ name, defaulted }));
 }
 function configReadEffect(read) {
   return {
@@ -4066,15 +4438,23 @@ function configReadEffect(read) {
   };
 }
 function envReadAt(node) {
+  const site = envSiteAt(node);
+  if (site === null) {
+    return null;
+  }
+  const name = stringLiteralValue(site.name);
+  return name === null ? null : { name, defaulted: site.defaulted };
+}
+function envSiteAt(node) {
   if (node.type === "element_reference") {
-    return elementRead(node);
+    return elementSite(node);
   }
   if (node.type === "call") {
-    return fetchRead(node);
+    return fetchSite(node);
   }
   return null;
 }
-function elementRead(node) {
+function elementSite(node) {
   const object = field(node, "object");
   if (object === null || !isEnv(object) || isAssignedTo(node)) {
     return null;
@@ -4082,24 +4462,23 @@ function elementRead(node) {
   const index = node.namedChildren.find(
     (child) => child !== null && child.id !== object.id
   );
-  const name = index === void 0 ? null : stringLiteralValue(index);
-  if (name === null) {
+  if (index === void 0) {
     return null;
   }
-  return { name, defaulted: isDefaultedAt(node) };
+  return { read: node, name: index, defaulted: isDefaultedAt(node) };
 }
-function fetchRead(node) {
+function fetchSite(node) {
   const receiver = field(node, "receiver");
   if (receiver === null || !isEnv(receiver) || field(node, "method")?.text !== "fetch") {
     return null;
   }
   const { positional } = readCallArgs(field(node, "arguments"));
-  const name = positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
-  if (name === null) {
+  const name = positional[0];
+  if (name === void 0) {
     return null;
   }
   const hasDefault = positional.length > 1 || field(node, "block") !== null;
-  return { name, defaulted: hasDefault || isDefaultedAt(node) };
+  return { read: node, name, defaulted: hasDefault || isDefaultedAt(node) };
 }
 function isEnv(node) {
   if (node.type === "constant") {
@@ -4273,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) {
@@ -4311,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;
   }
@@ -4338,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) {
@@ -4363,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;
 }
@@ -4376,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) {
@@ -4413,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);
@@ -4423,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));
     }
   }
@@ -4447,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",
@@ -4467,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]))
   );
@@ -4499,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;
   }
@@ -4507,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 = [];
@@ -4586,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 = [];
@@ -4598,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));
     }
@@ -4606,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",
@@ -4742,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) {
@@ -5082,8 +5806,12 @@ function bodyOfMethod(method, file, bodyRead = {}) {
     bodyRead.facts
   );
   const storage = bodyRead.storage;
+  const facts = bodyRead.facts;
   const extra = [
-    ...envReadEffects(method),
+    ...envReadEffects(
+      method,
+      facts === void 0 ? void 0 : { db: facts, file }
+    ),
     ...storage === void 0 ? [] : storageEffects(callsUnder2(method), file, storage, method)
   ];
   return {
@@ -5859,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";
@@ -5975,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;
@@ -5984,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);
 }
@@ -6165,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, {
@@ -6212,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)) {
@@ -6248,7 +7040,8 @@ async function reachedFunctions(seeds, options) {
     argTargetsByKey,
     parameterCallsByKey,
     propertyReadsByKey,
-    passedPositions
+    passedPositions,
+    followedKeys
   };
 }
 function keyOf(target) {
@@ -6287,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)
@@ -6305,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)
@@ -6312,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;
@@ -6355,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)
@@ -6489,8 +7314,8 @@ function parameterName(param) {
 }
 
 // src/reach/context.ts
-var METHOD_TYPES4 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
-async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dynamicNames = /* @__PURE__ */ new Map()) {
+var METHOD_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+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();
@@ -6500,7 +7325,7 @@ async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dyna
       classes.push({ file, info });
       classNames.set(nodeId(file, info.node), info.qualifiedName);
       for (const statement of namedChildren(info.bodyNode)) {
-        if (METHOD_TYPES4.has(statement.type)) {
+        if (METHOD_TYPES3.has(statement.type)) {
           classOfMethod.set(nodeId(file, statement), info.qualifiedName);
         }
       }
@@ -6566,7 +7391,8 @@ async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dyna
     classNames,
     definitions,
     bodyBlocks,
-    dynamicNames
+    dynamicNames,
+    loaders
   };
 }
 function namedChildren(node) {
@@ -6634,6 +7460,7 @@ function factsForFile(options) {
   const db = new Database2();
   const bodyBlocks = bodyBlocksIn(options.packs);
   emitValueFacts(db, options.file, options.root, bodyBlocks);
+  emitEnvFacts(db, options.file, options.root);
   emitConstantBindings(db, [
     collectFileConstants(
       options.file,
@@ -6650,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) ?? "";
@@ -6705,6 +7545,7 @@ async function extractRubyProject(options) {
       }
       parsed.push({ file, root });
       emitValueFacts(db, file, root, bodyBlocks);
+      emitEnvFacts(db, file, root);
       for (const [key, method] of methodDefinitionsIn(file, root)) {
         definitions.set(key, method);
       }
@@ -6721,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]))
@@ -6728,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 = [];
@@ -6782,23 +7638,34 @@ async function extractRubyProject(options) {
         });
       }
     }
-    const loadTimeReads = timer.time("discover", () => envReadEffects(root));
-    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) {
@@ -6836,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));
     }
@@ -6945,20 +7815,9 @@ function findRubyFiles(root) {
 
 // src/facts/why.ts
 var WITNESS_RULES = [...RESOLUTION_RULES, ...RUBY_RULES];
-var METHOD_TYPES5 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 function namedChildrenOf(node) {
   return node.namedChildren.filter((child) => child !== null);
 }
-function enclosingMethod2(node) {
-  let current = node.parent;
-  while (current !== null) {
-    if (METHOD_TYPES5.has(current.type)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
 function indexFile(file, root, locations) {
   const walk = (node) => {
     locations.set(nodeId(file, node), { file, node });
@@ -6994,7 +7853,7 @@ function width(node) {
   return node.endIndex - node.startIndex;
 }
 function askedKey(value) {
-  const enclosing = enclosingMethod2(value.node);
+  const enclosing = enclosingDefinition(value.node);
   return calleeKeyOf(value.file, value.node, enclosing) ?? readKey(value.file, value.node, enclosing);
 }
 var RubyWhySession = class {
@@ -7209,6 +8068,8 @@ export {
   resolveConstantFile,
   rubyStubEvidence,
   runStatements,
+  storageClaims,
+  storageEffects,
   stringLiteralValue,
   stringValueOf,
   symbolValue,