@suss/adapter-ruby 0.23.0 → 0.24.1

package/dist/index.cjs

@@ -607,113 +607,15 @@ function inheritedStatements(ancestry, blockConfigures) {
 }
 
 // src/discovery.ts
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
+var import_behavioral_ir3 = require("@suss/behavioral-ir");
 var import_extractor5 = require("@suss/extractor");
 
-// src/envReads.ts
+// src/clientCalls.ts
 var import_behavioral_ir = require("@suss/behavioral-ir");
-var import_extractor2 = require("@suss/extractor");
-var RUBY_ENV_RECOGNITION = "ruby-env";
-var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
-function envReadEffects(root) {
-  const effects = [];
-  (0, import_extractor2.walkDescendants)(root, null, {
-    at: (node) => {
-      const read = envReadAt(node);
-      if (read !== null) {
-        effects.push(configReadEffect(read));
-      }
-    },
-    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? import_extractor2.SKIP_CHILDREN : null
-  });
-  return effects;
-}
-function configReadEffect(read) {
-  return {
-    type: "interaction",
-    binding: (0, import_behavioral_ir.runtimeConfigBinding)({
-      recognition: RUBY_ENV_RECOGNITION,
-      deploymentTarget: "lambda",
-      instanceName: "<unknown>"
-    }),
-    callee: `ENV["${read.name}"]`,
-    interaction: {
-      class: "config-read",
-      name: read.name,
-      defaulted: read.defaulted
-    }
-  };
-}
-function envReadAt(node) {
-  if (node.type === "element_reference") {
-    return elementRead(node);
-  }
-  if (node.type === "call") {
-    return fetchRead(node);
-  }
-  return null;
-}
-function elementRead(node) {
-  const object = field(node, "object");
-  if (object === null || !isEnv(object) || isAssignedTo(node)) {
-    return null;
-  }
-  const index = node.namedChildren.find(
-    (child) => child !== null && child.id !== object.id
-  );
-  const name = index === void 0 ? null : stringLiteralValue(index);
-  if (name === null) {
-    return null;
-  }
-  return { name, defaulted: isDefaultedAt(node) };
-}
-function fetchRead(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) {
-    return null;
-  }
-  const hasDefault = positional.length > 1 || field(node, "block") !== null;
-  return { name, defaulted: hasDefault || isDefaultedAt(node) };
-}
-function isEnv(node) {
-  if (node.type === "constant") {
-    return node.text === "ENV";
-  }
-  return node.type === "scope_resolution" && field(node, "scope") === null && field(node, "name")?.text === "ENV";
-}
-function isAssignedTo(node) {
-  const parent = node.parent;
-  return parent !== null && (parent.type === "assignment" || parent.type === "operator_assignment") && field(parent, "left")?.id === node.id;
-}
-function isDefaultedAt(node) {
-  let child = node;
-  let parent = node.parent;
-  while (parent !== null) {
-    if (parent.type === "parenthesized_statements") {
-      child = parent;
-      parent = parent.parent;
-      continue;
-    }
-    if (parent.type !== "binary" || field(parent, "operator")?.text !== "||") {
-      return false;
-    }
-    if (field(parent, "left")?.id === child.id) {
-      return true;
-    }
-    child = parent;
-    parent = parent.parent;
-  }
-  return false;
-}
+var import_values5 = require("@suss/values");
 
-// src/responseStatus.ts
-var import_extractor3 = require("@suss/extractor");
-var import_values4 = require("@suss/values");
+// src/paths/effects.ts
+var import_extractor2 = require("@suss/extractor");
 
 // src/paths/bareCalls.ts
 var PARAMETER_LIST_TYPES = [
@@ -1076,17 +978,297 @@ var Lowerer = class {
     }
     return this.attach({ kind: "opaque", exitKind: exitKindOf(node) }, [node]);
   }
-};
-function lowerRubyBody(body, terminals, responseCalls = []) {
-  const lowerer = new Lowerer(
-    new Map(terminals.map((terminal) => [terminal.id, terminal])),
-    new NodeSet(responseCalls)
-  );
-  return {
-    statements: lowerer.lowerBlock(body),
-    terminalsByStmt: lowerer.terminalsByStmt,
-    terminalHome: lowerer.terminalHome
-  };
+};
+function lowerRubyBody(body, terminals, responseCalls = []) {
+  const lowerer = new Lowerer(
+    new Map(terminals.map((terminal) => [terminal.id, terminal])),
+    new NodeSet(responseCalls)
+  );
+  return {
+    statements: lowerer.lowerBlock(body),
+    terminalsByStmt: lowerer.terminalsByStmt,
+    terminalHome: lowerer.terminalHome
+  };
+}
+
+// src/paths/effects.ts
+var RAISE_NAMES2 = /* @__PURE__ */ new Set(["raise", "fail"]);
+var BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "body_statement",
+  "then",
+  "else",
+  "do_block",
+  "block"
+]);
+var LITERAL_ARGS = {
+  string: (node) => ({
+    kind: "string",
+    value: node.text.replace(/^["']|["']$/g, "")
+  }),
+  integer: (node) => {
+    const value = Number.parseInt(node.text, 10);
+    return Number.isNaN(value) ? null : { kind: "number", value };
+  },
+  float: (node) => {
+    const value = Number.parseFloat(node.text);
+    return Number.isNaN(value) ? null : { kind: "number", value };
+  },
+  true: () => ({ kind: "boolean", value: true }),
+  false: () => ({ kind: "boolean", value: false }),
+  simple_symbol: (node) => ({ kind: "string", value: node.text.slice(1) })
+};
+function children(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function withoutChainLinks(calls) {
+  const isLink = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    const receiver = field(call, "receiver");
+    if (receiver !== null && receiver.type === "call") {
+      isLink.add(receiver.id);
+    }
+  }
+  return calls.filter((call) => !isLink.has(call.id));
+}
+function calleeMethodName(call) {
+  if (call.type === "identifier") {
+    return call.text;
+  }
+  const method = field(call, "method");
+  if (method !== null) {
+    return method.text;
+  }
+  return field(call, "receiver") !== null ? "call" : children(call)[0]?.text;
+}
+function isPropertyRead(node) {
+  if (field(node, "receiver") === null || field(node, "arguments") !== null) {
+    return false;
+  }
+  return calleeMethodName(node) !== "call";
+}
+function isRaise2(node) {
+  const method = field(node, "method") ?? children(node)[0] ?? null;
+  return field(node, "receiver") === null && method !== null && RAISE_NAMES2.has(method.text);
+}
+var NO_INHERITED_METHODS = /* @__PURE__ */ new Set();
+function isInherited(node, inherited) {
+  const method = field(node, "method");
+  return field(node, "receiver") === null && method !== null && inherited.has(method.text);
+}
+function isCall(node, locals, inherited) {
+  if (node.type === "call") {
+    return !isPropertyRead(node) && !isRaise2(node) && !isInherited(node, inherited);
+  }
+  return isBareMethodCall(node, locals) && !RAISE_NAMES2.has(node.text) && !inherited.has(node.text);
+}
+function collectCalls(node, locals, inherited, found) {
+  for (const child of children(node)) {
+    if (OWN_BODY_TYPES.has(child.type)) {
+      continue;
+    }
+    if (isCall(child, locals, inherited)) {
+      found.push(child);
+    }
+    collectCalls(child, locals, inherited, found);
+  }
+  return found;
+}
+function bodyCalls(definitionNode, inherited = NO_INHERITED_METHODS) {
+  const body = field(definitionNode, "body");
+  if (body === null) {
+    return [];
+  }
+  return collectCalls(body, localNamesIn(definitionNode), inherited, []);
+}
+function calleeText(call) {
+  const receiver = field(call, "receiver");
+  const method = calleeMethodName(call);
+  if (method === void 0) {
+    return call.text;
+  }
+  return receiver === null ? method : `${receiver.text}.${method}`;
+}
+function argOf(node) {
+  const literal = LITERAL_ARGS[node.type]?.(node);
+  if (literal !== null && literal !== void 0) {
+    return literal;
+  }
+  if (node.type === "call" && !isPropertyRead(node)) {
+    return { kind: "call", callee: calleeText(node), args: argsOf(node) };
+  }
+  return { kind: "identifier", name: node.text };
+}
+function argsOf(call) {
+  const args = field(call, "arguments");
+  if (args === null) {
+    return [];
+  }
+  return children(args).map(
+    (child) => child.type === "pair" ? argOf(field(child, "value") ?? child) : argOf(child)
+  );
+}
+function enclosingStatement(call, body) {
+  let current = call;
+  while (current.parent !== null) {
+    if (BLOCK_TYPES.has(current.parent.type) || current.parent.id === body.id) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return current;
+}
+function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS) {
+  const body = field(definitionNode, "body");
+  if (body === null) {
+    return [];
+  }
+  const calls = withoutChainLinks(bodyCalls(definitionNode, inherited));
+  if (calls.length === 0) {
+    return [];
+  }
+  const statementOf2 = /* @__PURE__ */ new Map();
+  const statements = [];
+  for (const call of calls) {
+    const statement = enclosingStatement(call, body);
+    statementOf2.set(call.id, statement);
+    statements.push(statement);
+  }
+  const lowered = lowerRubyBody(body, statements);
+  const enumerated = (0, import_extractor2.enumerateOrDegrade)(
+    {
+      statements: lowered.statements,
+      terminalsByStmt: lowered.terminalsByStmt
+    },
+    statements
+  );
+  return calls.map((call) => {
+    const statement = statementOf2.get(call.id);
+    const conditions = (0, import_extractor2.sharedGatingConditions)(
+      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
+    );
+    return {
+      type: "invocation",
+      callee: calleeText(call),
+      args: argsOf(call),
+      async: false,
+      ...conditions.length > 0 ? { preconditions: conditions } : {}
+    };
+  });
+}
+
+// src/responseStatus.ts
+var import_extractor3 = require("@suss/extractor");
+var import_values4 = require("@suss/values");
+
+// src/paths/predicates.ts
+var OPERATORS = {
+  "==": "eq",
+  "!=": "neq",
+  ">": "gt",
+  ">=": "gte",
+  "<": "lt",
+  "<=": "lte"
+};
+var CONVERSIONS = /* @__PURE__ */ new Set(["to_i", "to_s", "to_sym"]);
+var opaqueOf = (node) => ({
+  type: "opaque",
+  sourceText: node.text,
+  reason: "complexExpression"
+});
+function predicateOf(node) {
+  if (node.type === "parenthesized_statements") {
+    const inner = node.namedChildren[0];
+    return inner == null ? opaqueOf(node) : predicateOf(inner);
+  }
+  if (node.type === "unary" && field(node, "operator")?.text === "!") {
+    const operand2 = field(node, "operand") ?? node.namedChildren[0];
+    return operand2 == null ? opaqueOf(node) : { type: "negation", operand: predicateOf(operand2) };
+  }
+  if (node.type === "binary") {
+    return binaryOf(node);
+  }
+  const asked = calledMethod(node);
+  if (asked === "nil?") {
+    const receiver = field(node, "receiver");
+    return receiver === null ? opaqueOf(node) : { type: "nullCheck", subject: valueRefOf(receiver), negated: false };
+  }
+  if (node.type === "identifier" || memberChain(node) !== null) {
+    return {
+      type: "truthinessCheck",
+      subject: valueRefOf(node),
+      negated: false
+    };
+  }
+  return opaqueOf(node);
+}
+function binaryOf(node) {
+  const operator = field(node, "operator")?.text ?? "";
+  const left = field(node, "left");
+  const right = field(node, "right");
+  if (left === null || right === null) {
+    return opaqueOf(node);
+  }
+  const op = OPERATORS[operator];
+  if (op !== void 0) {
+    return {
+      type: "comparison",
+      left: valueRefOf(left),
+      op,
+      right: valueRefOf(right)
+    };
+  }
+  if (operator === "&&" || operator === "||" || operator === "and" || operator === "or") {
+    return {
+      type: "compound",
+      op: operator === "&&" || operator === "and" ? "and" : "or",
+      operands: [predicateOf(left), predicateOf(right)]
+    };
+  }
+  return opaqueOf(node);
+}
+function valueRefOf(node) {
+  const literal = literalOf(node);
+  if (literal !== null) {
+    return literal;
+  }
+  const chain = memberChain(node);
+  if (chain !== null) {
+    const [name, ...accessChain] = chain;
+    if (name !== void 0 && accessChain.length > 0) {
+      return { type: "dependency", name, accessChain };
+    }
+  }
+  return { type: "unresolved", sourceText: node.text };
+}
+function literalOf(node) {
+  if (node.type === "integer") {
+    const value = Number.parseInt(node.text, 10);
+    return Number.isNaN(value) ? null : { type: "literal", value };
+  }
+  const string = stringLiteralValue(node);
+  if (string !== null) {
+    return { type: "literal", value: string };
+  }
+  const boolean = booleanLiteralValue(node);
+  return boolean === null ? null : { type: "literal", value: boolean };
+}
+function memberChain(node, tail = []) {
+  if (node.type === "identifier") {
+    return [node.text, ...tail];
+  }
+  const called = calledMethod(node);
+  const receiver = field(node, "receiver");
+  if (called === null || receiver === null || field(node, "arguments") !== null) {
+    return null;
+  }
+  const rest = CONVERSIONS.has(called) && tail.length === 0 ? tail : [called, ...tail];
+  return memberChain(receiver, rest);
+}
+function calledMethod(node) {
+  if (node.type !== "call" || field(node, "block") !== null) {
+    return null;
+  }
+  return field(node, "method")?.text ?? null;
 }
 
 // src/values/evaluator.ts
@@ -1144,7 +1326,7 @@ function paramNameOf(param) {
 function declaredParamNames(method) {
   const params = field(method, "parameters");
   const declared = /* @__PURE__ */ new Set();
-  for (const param of params === null ? [] : children(params)) {
+  for (const param of params === null ? [] : children2(params)) {
     const name = paramNameOf(param);
     if (name !== null) {
       declared.add(name.text);
@@ -1158,7 +1340,7 @@ function readKey(filePath, node, enclosing) {
   }
   const parent = node.parent;
   if (parent !== null && parent.type === "call" && field(parent, "method")?.id === node.id && field(parent, "receiver") !== null) {
-    return isPropertyRead(parent) ? nodeId(filePath, parent) : nodeId(filePath, node);
+    return isPropertyRead2(parent) ? nodeId(filePath, parent) : nodeId(filePath, node);
   }
   if (enclosing !== null && declaredParamNames(enclosing).has(node.text)) {
     return `${nodeId(filePath, enclosing)}#${node.text}`;
@@ -1186,7 +1368,7 @@ var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
   "parenthesized_statements"
 ]);
 var ARRAY_TYPES = /* @__PURE__ */ new Set(["array", "string_array", "symbol_array"]);
-function children(node) {
+function children2(node) {
   return node.namedChildren.filter((child) => child !== null);
 }
 function add(emitter, relation, ...tuple) {
@@ -1214,8 +1396,8 @@ function pairKeyText(key) {
   }
   return null;
 }
-function isPropertyRead(node) {
-  return node.type === "call" && field(node, "receiver") !== null && field(node, "arguments") === null && children(node).every(
+function isPropertyRead2(node) {
+  return node.type === "call" && field(node, "receiver") !== null && field(node, "arguments") === null && children2(node).every(
     (child) => child.type !== "do_block" && child.type !== "block"
   );
 }
@@ -1254,7 +1436,7 @@ function emitCall(emitter, call) {
   }
   const args = field(call, "arguments");
   let position = 0;
-  for (const argument of args === null ? [] : children(args)) {
+  for (const argument of args === null ? [] : children2(args)) {
     if (argument.type === "pair") {
       const key = field(argument, "key");
       const value = field(argument, "value");
@@ -1284,7 +1466,7 @@ function emitArray(emitter, array) {
   const objectKey = nodeId(emitter.filePath, array);
   add(emitter, "objectValue", objectKey);
   let position = 0;
-  for (const element of children(array)) {
+  for (const element of children2(array)) {
     add(
       emitter,
       "holdsProperty",
@@ -1298,7 +1480,7 @@ function emitArray(emitter, array) {
 function emitHash(emitter, hash) {
   const objectKey = nodeId(emitter.filePath, hash);
   add(emitter, "objectValue", objectKey);
-  for (const pair of children(hash)) {
+  for (const pair of children2(hash)) {
     if (pair.type !== "pair") {
       continue;
     }
@@ -1312,7 +1494,7 @@ function emitHash(emitter, hash) {
   }
 }
 function walkExpressions(node, visit) {
-  for (const child of children(node)) {
+  for (const child of children2(node)) {
     if (OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
@@ -1322,7 +1504,7 @@ function walkExpressions(node, visit) {
 }
 function emitExpressionFacts(emitter, node) {
   walkExpressions(node, (child) => {
-    if (isPropertyRead(child)) {
+    if (isPropertyRead2(child)) {
       emitPropertyRead(emitter, child);
     } else if (child.type === "call") {
       emitCall(emitter, child);
@@ -1342,7 +1524,7 @@ function emitExpressionFacts(emitter, node) {
   });
 }
 function implicitReturn(body) {
-  const statements = children(body).filter(
+  const statements = children2(body).filter(
     (child) => child.type !== "rescue" && child.type !== "ensure"
   );
   const last = statements[statements.length - 1];
@@ -1354,7 +1536,7 @@ function emitMethodFacts(emitter, method) {
   const params = field(method, "parameters");
   const declared = /* @__PURE__ */ new Set();
   let position = 0;
-  for (const param of params === null ? [] : children(params)) {
+  for (const param of params === null ? [] : children2(params)) {
     const paramName = paramNameOf(param);
     if (paramName !== null) {
       declared.add(paramName.text);
@@ -1373,7 +1555,7 @@ function emitMethodFacts(emitter, method) {
     return funcKey;
   }
   const recordNested = (node) => {
-    for (const child of children(node)) {
+    for (const child of children2(node)) {
       if (OWN_BODY_TYPES.has(child.type)) {
         add(emitter, "containsFn", funcKey, nodeId(emitter.filePath, child));
         continue;
@@ -1384,8 +1566,8 @@ function emitMethodFacts(emitter, method) {
   recordNested(body);
   walkExpressions(body, (child) => {
     if (child.type === "return") {
-      const first = children(child)[0];
-      const returned = first?.type === "argument_list" ? children(first)[0] : first;
+      const first = children2(child)[0];
+      const returned = first?.type === "argument_list" ? children2(first)[0] : first;
       if (returned !== void 0) {
         add(inside, "returnsValue", funcKey, valueKey(inside, returned));
       }
@@ -1429,13 +1611,13 @@ function emitClassFacts(emitter, cls) {
   const classKey = nodeId(emitter.filePath, cls);
   add(emitter, "objectValue", classKey);
   const superclass = field(cls, "superclass");
-  const base = superclass === null ? null : children(superclass)[0] ?? null;
+  const base = superclass === null ? null : children2(superclass)[0] ?? null;
   if (base !== null) {
     add(emitter, "extends", classKey, valueKey(emitter, base));
     add(emitter, "extendsNamed", classKey, base.text);
   }
   const body = field(cls, "body");
-  for (const statement of body === null ? [] : children(body)) {
+  for (const statement of body === null ? [] : children2(body)) {
     if (statement.type === "assignment") {
       const left = field(statement, "left");
       const right = field(statement, "right");
@@ -1477,7 +1659,7 @@ function emitValueFacts(db, filePath, root) {
     add(emitter, "exportsAs", filePath, name.text, key);
   };
   const walk = (node) => {
-    for (const child of children(node)) {
+    for (const child of children2(node)) {
       if (NESTING_TYPES.has(child.type)) {
         declaresName(child, emitClassFacts(emitter, child));
         continue;
@@ -1508,7 +1690,7 @@ var OWN_ROOT_TYPES = /* @__PURE__ */ new Set([
   "module",
   "singleton_class"
 ]);
-var BLOCK_TYPES = /* @__PURE__ */ new Set(["block", "do_block"]);
+var BLOCK_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
 var METHOD_TYPES2 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 var NAME_TYPES = /* @__PURE__ */ new Set([
   "identifier",
@@ -2014,7 +2196,7 @@ function isTailExpression(node) {
   if (owner.type === "block" && owner.parent?.type === "lambda") {
     return true;
   }
-  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES.has(owner.type)) {
+  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES2.has(owner.type)) {
     return true;
   }
   if (owner.type === "when") {
@@ -2033,7 +2215,7 @@ function isRoot(node) {
   if (OWN_ROOT_TYPES.has(node.type)) {
     return true;
   }
-  return BLOCK_TYPES.has(node.type) && node.parent?.type === "call";
+  return BLOCK_TYPES2.has(node.type) && node.parent?.type === "call";
 }
 function isPathStatement(node, parent) {
   if (node.type === "elsif") {
@@ -2087,7 +2269,7 @@ function functionOf(node) {
       body: bodyOf(block)
     };
   }
-  if (BLOCK_TYPES.has(node.type)) {
+  if (BLOCK_TYPES2.has(node.type)) {
     return {
       parameters: parametersOf(field(node, "parameters")),
       body: bodyOf(node)
@@ -2405,6 +2587,18 @@ var calleeRows = [
     kind: "callee",
     origin: { module: "Kernel", name: "String" },
     apply: ({ args }) => ({ result: (0, import_values.concat)([(0, import_values.operand)(args[0])]) })
+  },
+  // A URI is the string it was parsed from, as far as a reader of paths
+  // is concerned, and both spellings are the standard library's own.
+  {
+    kind: "callee",
+    origin: { module: "Kernel", name: "URI" },
+    apply: ({ args }) => ({ result: (0, import_values.concat)([(0, import_values.operand)(args[0])]) })
+  },
+  {
+    kind: "callee",
+    origin: { module: "URI", name: "parse" },
+    apply: ({ args }) => ({ result: (0, import_values.concat)([(0, import_values.operand)(args[0])]) })
   }
 ];
 var rubyRows = [
@@ -2592,7 +2786,7 @@ function effectsReaching(effects, conditions) {
 function conditionOf(condition) {
   return {
     sourceText: condition.sourceText,
-    structured: null,
+    structured: condition.expression === null ? null : predicateOf(condition.expression),
     polarity: condition.polarity,
     source: condition.source
   };
@@ -2646,55 +2840,414 @@ function handsOnBranch(outcome, effects, extraEffects) {
     isDefault: outcome.conditions.length === 0
   };
 }
+function returnPathBranches(method, effects) {
+  const body = field(method, "body");
+  if (body === null) {
+    return null;
+  }
+  const returns = collectReturns(body, []);
+  const lowered = lowerRubyBody(body, returns, []);
+  const enumerated = (0, import_extractor3.enumerateOrDegrade)(
+    {
+      statements: lowered.statements,
+      terminalsByStmt: lowered.terminalsByStmt
+    },
+    returns
+  );
+  const branches = [];
+  const push = (paths, at) => {
+    for (const path7 of paths) {
+      const conditions = path7.map(conditionOf);
+      branches.push({
+        conditions,
+        terminal: {
+          kind: "return",
+          statusCode: null,
+          body: null,
+          exceptionType: null,
+          message: null,
+          component: null,
+          renderTree: null,
+          delegateTarget: null,
+          emitEvent: null,
+          location: at
+        },
+        effects: effectsReaching(effects, conditions),
+        location: at,
+        isDefault: conditions.length === 0
+      });
+    }
+  };
+  for (const statement of returns) {
+    push(enumerated.byTerminal.get(statement) ?? [], rangeOf(statement));
+  }
+  push(enumerated.fallthrough, rangeOf(method));
+  return branches.length === 0 ? null : branches;
+}
 function responseBranches(method, pattern, effects, extraEffects, options = {}) {
   const declarations = pattern.responseStatusCalls ?? [];
   const body = field(method, "body");
   if (declarations.length === 0 || body === null) {
     return null;
   }
-  const byName = declarationsByName(declarations);
-  const locals = localNamesIn(method);
-  const responses = collectResponseCalls(body, byName, locals, []);
-  const returns = collectReturns(body, []);
-  const lowered = lowerRubyBody(body, returns, responses);
-  const bareReturns = returns.filter(
-    (node) => lowered.terminalHome.has(node) && collectResponseCalls(node, byName, locals, []).length === 0
-  );
-  const terminals = [...responses, ...bareReturns];
-  const enumerated = (0, import_extractor3.enumerateOrDegrade)(
-    {
-      statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
-    },
-    terminals
+  const byName = declarationsByName(declarations);
+  const locals = localNamesIn(method);
+  const responses = collectResponseCalls(body, byName, locals, []);
+  const returns = collectReturns(body, []);
+  const lowered = lowerRubyBody(body, returns, responses);
+  const bareReturns = returns.filter(
+    (node) => lowered.terminalHome.has(node) && collectResponseCalls(node, byName, locals, []).length === 0
+  );
+  const terminals = [...responses, ...bareReturns];
+  const enumerated = (0, import_extractor3.enumerateOrDegrade)(
+    {
+      statements: lowered.statements,
+      terminalsByStmt: lowered.terminalsByStmt
+    },
+    terminals
+  );
+  const statusNames = pattern.statusCodeNames ?? {};
+  const outcomes = [];
+  for (const terminal of terminals) {
+    const declaration = declarationOf(terminal, byName, locals);
+    const reading = declaration === void 0 ? import_extractor3.absentReading : readingOfCall(terminal, declaration, statusNames);
+    for (const path7 of enumerated.byTerminal.get(terminal) ?? []) {
+      outcomes.push({
+        conditions: path7.map(conditionOf),
+        reading,
+        location: rangeOf(terminal)
+      });
+    }
+  }
+  for (const path7 of enumerated.fallthrough) {
+    outcomes.push({
+      conditions: path7.map(conditionOf),
+      reading: import_extractor3.absentReading,
+      location: rangeOf(method),
+      fellThrough: true
+    });
+  }
+  if (outcomes.length === 0) {
+    return null;
+  }
+  return outcomes.map(
+    (outcome) => branchOf(outcome, pattern, effects, extraEffects, options)
+  );
+}
+
+// src/clientCalls.ts
+function clientCallUnits(root, pack, pattern, options) {
+  const units = [];
+  for (const method of methodDefinitions(root)) {
+    const name = field(method, "name")?.text;
+    if (name === void 0) {
+      continue;
+    }
+    for (const call of callsUnder(method)) {
+      const request = requestCall(call, method, pattern, options);
+      if (request === null) {
+        continue;
+      }
+      units.push(clientUnit(method, name, request, pattern, pack, options));
+    }
+  }
+  return units;
+}
+function methodDefinitions(node, found = []) {
+  for (const child of node.namedChildren) {
+    if (child === null) {
+      continue;
+    }
+    if (child.type === "method" || child.type === "singleton_method") {
+      found.push(child);
+    }
+    methodDefinitions(child, found);
+  }
+  return found;
+}
+function callsUnder(node, found = []) {
+  for (const child of node.namedChildren) {
+    if (child === null) {
+      continue;
+    }
+    if (child.type === "call") {
+      found.push(child);
+    }
+    callsUnder(child, found);
+  }
+  return found;
+}
+function requestCall(call, method, pattern, options) {
+  const receiver = field(call, "receiver");
+  const called = field(call, "method")?.text;
+  if (receiver === null || called === void 0) {
+    return null;
+  }
+  const prefix = receiverPrefix(receiver, method, pattern, options);
+  if (prefix === null) {
+    return null;
+  }
+  const args = readCallArgs(field(call, "arguments"));
+  const verb = pattern.verbMethodNames[called];
+  if (verb !== void 0) {
+    const path8 = urlIn(args, pattern, options);
+    return path8 === null ? null : { method: verb, path: prefix + path8 };
+  }
+  const sent = pattern.requestObject;
+  if (sent === void 0 || sent.attribute !== called) {
+    return null;
+  }
+  const built = requestBuilt(args.positional[0], method, sent);
+  if (built === null) {
+    return null;
+  }
+  const path7 = pathAt(built.url, options);
+  return path7 === null ? null : { method: built.method, path: prefix + path7 };
+}
+function requestBuilt(argument, method, sent) {
+  const written = argument === void 0 ? null : assignedCall(argument, method) ?? argument;
+  if (written === null || written.type !== "call") {
+    return null;
+  }
+  const requestClass = field(written, "receiver")?.text;
+  const verb = requestClass === void 0 ? void 0 : sent.constructors[requestClass];
+  if (verb === void 0) {
+    return null;
+  }
+  const args = readCallArgs(field(written, "arguments"));
+  return { method: verb, url: args.positional[sent.urlPosition] };
+}
+function assignedCall(node, method) {
+  if (node.type !== "identifier") {
+    return null;
+  }
+  const value = assignedValue(node.text, method);
+  return value !== null && value.type === "call" ? value : null;
+}
+function receiverPrefix(receiver, method, pattern, options) {
+  if (namesConstant(receiver, pattern.constantName)) {
+    return "";
+  }
+  if (receiver.type !== "identifier") {
+    return null;
+  }
+  const built = builtBy(receiver.text, method, pattern);
+  if (built === null) {
+    return null;
+  }
+  const keyword = pattern.builderUrlKeyword;
+  if (keyword === void 0) {
+    return "";
+  }
+  const base = readCallArgs(field(built, "arguments")).keyword[keyword];
+  const path7 = base === void 0 ? null : (0, import_values5.pathOf)(evaluatedValue(base, options.facts));
+  return path7 === void 0 || path7 === null ? "" : trimmed(path7);
+}
+function trimmed(path7) {
+  return path7 === "/" ? "" : path7.replace(/\/+$/, "");
+}
+function namesConstant(receiver, constantName) {
+  return (receiver.type === "constant" || receiver.type === "scope_resolution") && receiver.text === constantName;
+}
+function builtBy(name, method, pattern) {
+  const builders = pattern.receiverBuilders ?? [];
+  const value = builders.length === 0 ? null : assignedValue(name, method);
+  if (value === null || value.type !== "call" || !builders.includes(field(value, "method")?.text ?? "")) {
+    return null;
+  }
+  const receiver = field(value, "receiver");
+  return receiver !== null && namesConstant(receiver, pattern.constantName) ? value : null;
+}
+function assignedValue(name, method) {
+  const body = field(method, "body");
+  if (body === null) {
+    return null;
+  }
+  for (const statement of runStatements(body)) {
+    if (statement.type !== "assignment") {
+      continue;
+    }
+    if (field(statement, "left")?.text === name) {
+      return field(statement, "right");
+    }
+  }
+  return null;
+}
+function urlIn(args, pattern, options) {
+  const keyword = pattern.url.keyword;
+  const written = (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[pattern.url.position];
+  return pathAt(written, options);
+}
+function pathAt(written, options) {
+  if (written === void 0) {
+    return null;
+  }
+  const path7 = (0, import_values5.pathOf)(evaluatedValue(written, options.facts));
+  return path7 === void 0 || (0, import_behavioral_ir.namesNothing)(path7) ? null : path7;
+}
+function clientUnit(method, name, request, pattern, pack, options) {
+  const range = rangeOf(method);
+  return {
+    identity: {
+      name,
+      nameKind: "binding",
+      kind: "client",
+      file: options.filePath,
+      range,
+      span: spanOf(method),
+      exportName: name,
+      exportPath: [name]
+    },
+    boundaryBinding: (0, import_behavioral_ir.restBinding)({
+      transport: pack.protocol,
+      method: request.method,
+      path: request.path,
+      recognition: pack.name
+    }),
+    parameters: [],
+    branches: callerBranches(method, range),
+    ...responseAccessors(pattern),
+    bodyContent: "statements",
+    dependencyCalls: [],
+    declaredContract: null
+  };
+}
+function callerBranches(method, range) {
+  const effects = invocationEffects(method);
+  return returnPathBranches(method, effects) ?? [returnBranch(range, effects)];
+}
+function responseAccessors(pattern) {
+  const response = pattern.response;
+  if (response === void 0) {
+    return {};
+  }
+  return {
+    ...response.body === void 0 ? {} : { bodyAccessors: response.body },
+    ...response.statusCode === void 0 ? {} : { statusAccessors: response.statusCode },
+    ...response.success === void 0 ? {} : { successAccessors: response.success },
+    ...response.failureDelivery === void 0 ? {} : { failureDelivery: response.failureDelivery }
+  };
+}
+function returnBranch(range, effects) {
+  return {
+    conditions: [],
+    terminal: {
+      kind: "return",
+      statusCode: null,
+      body: null,
+      exceptionType: null,
+      message: null,
+      component: null,
+      renderTree: null,
+      delegateTarget: null,
+      emitEvent: null,
+      location: range
+    },
+    effects,
+    location: range,
+    isDefault: true
+  };
+}
+
+// src/envReads.ts
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
+var import_extractor4 = require("@suss/extractor");
+var RUBY_ENV_RECOGNITION = "ruby-env";
+var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
+function envReadEffects(root) {
+  const effects = [];
+  (0, import_extractor4.walkDescendants)(root, null, {
+    at: (node) => {
+      const read = envReadAt(node);
+      if (read !== null) {
+        effects.push(configReadEffect(read));
+      }
+    },
+    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? import_extractor4.SKIP_CHILDREN : null
+  });
+  return effects;
+}
+function configReadEffect(read) {
+  return {
+    type: "interaction",
+    binding: (0, import_behavioral_ir2.runtimeConfigBinding)({
+      recognition: RUBY_ENV_RECOGNITION,
+      deploymentTarget: "lambda",
+      instanceName: "<unknown>"
+    }),
+    callee: `ENV["${read.name}"]`,
+    interaction: {
+      class: "config-read",
+      name: read.name,
+      defaulted: read.defaulted
+    }
+  };
+}
+function envReadAt(node) {
+  if (node.type === "element_reference") {
+    return elementRead(node);
+  }
+  if (node.type === "call") {
+    return fetchRead(node);
+  }
+  return null;
+}
+function elementRead(node) {
+  const object = field(node, "object");
+  if (object === null || !isEnv(object) || isAssignedTo(node)) {
+    return null;
+  }
+  const index = node.namedChildren.find(
+    (child) => child !== null && child.id !== object.id
   );
-  const statusNames = pattern.statusCodeNames ?? {};
-  const outcomes = [];
-  for (const terminal of terminals) {
-    const declaration = declarationOf(terminal, byName, locals);
-    const reading = declaration === void 0 ? import_extractor3.absentReading : readingOfCall(terminal, declaration, statusNames);
-    for (const path7 of enumerated.byTerminal.get(terminal) ?? []) {
-      outcomes.push({
-        conditions: path7.map(conditionOf),
-        reading,
-        location: rangeOf(terminal)
-      });
-    }
+  const name = index === void 0 ? null : stringLiteralValue(index);
+  if (name === null) {
+    return null;
   }
-  for (const path7 of enumerated.fallthrough) {
-    outcomes.push({
-      conditions: path7.map(conditionOf),
-      reading: import_extractor3.absentReading,
-      location: rangeOf(method),
-      fellThrough: true
-    });
+  return { name, defaulted: isDefaultedAt(node) };
+}
+function fetchRead(node) {
+  const receiver = field(node, "receiver");
+  if (receiver === null || !isEnv(receiver) || field(node, "method")?.text !== "fetch") {
+    return null;
   }
-  if (outcomes.length === 0) {
+  const { positional } = readCallArgs(field(node, "arguments"));
+  const name = positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
+  if (name === null) {
     return null;
   }
-  return outcomes.map(
-    (outcome) => branchOf(outcome, pattern, effects, extraEffects, options)
-  );
+  const hasDefault = positional.length > 1 || field(node, "block") !== null;
+  return { name, defaulted: hasDefault || isDefaultedAt(node) };
+}
+function isEnv(node) {
+  if (node.type === "constant") {
+    return node.text === "ENV";
+  }
+  return node.type === "scope_resolution" && field(node, "scope") === null && field(node, "name")?.text === "ENV";
+}
+function isAssignedTo(node) {
+  const parent = node.parent;
+  return parent !== null && (parent.type === "assignment" || parent.type === "operator_assignment") && field(parent, "left")?.id === node.id;
+}
+function isDefaultedAt(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== null) {
+    if (parent.type === "parenthesized_statements") {
+      child = parent;
+      parent = parent.parent;
+      continue;
+    }
+    if (parent.type !== "binary" || field(parent, "operator")?.text !== "||") {
+      return false;
+    }
+    if (field(parent, "left")?.id === child.id) {
+      return true;
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return false;
 }
 
 // src/filters.ts
@@ -2882,172 +3435,6 @@ function namesUnder(node) {
   return names;
 }
 
-// src/paths/effects.ts
-var import_extractor4 = require("@suss/extractor");
-var RAISE_NAMES2 = /* @__PURE__ */ new Set(["raise", "fail"]);
-var BLOCK_TYPES2 = /* @__PURE__ */ new Set([
-  "body_statement",
-  "then",
-  "else",
-  "do_block",
-  "block"
-]);
-var LITERAL_ARGS = {
-  string: (node) => ({
-    kind: "string",
-    value: node.text.replace(/^["']|["']$/g, "")
-  }),
-  integer: (node) => {
-    const value = Number.parseInt(node.text, 10);
-    return Number.isNaN(value) ? null : { kind: "number", value };
-  },
-  float: (node) => {
-    const value = Number.parseFloat(node.text);
-    return Number.isNaN(value) ? null : { kind: "number", value };
-  },
-  true: () => ({ kind: "boolean", value: true }),
-  false: () => ({ kind: "boolean", value: false }),
-  simple_symbol: (node) => ({ kind: "string", value: node.text.slice(1) })
-};
-function children2(node) {
-  return node.namedChildren.filter((child) => child !== null);
-}
-function withoutChainLinks(calls) {
-  const isLink = /* @__PURE__ */ new Set();
-  for (const call of calls) {
-    const receiver = field(call, "receiver");
-    if (receiver !== null && receiver.type === "call") {
-      isLink.add(receiver.id);
-    }
-  }
-  return calls.filter((call) => !isLink.has(call.id));
-}
-function calleeMethodName(call) {
-  if (call.type === "identifier") {
-    return call.text;
-  }
-  const method = field(call, "method");
-  if (method !== null) {
-    return method.text;
-  }
-  return field(call, "receiver") !== null ? "call" : children2(call)[0]?.text;
-}
-function isPropertyRead2(node) {
-  if (field(node, "receiver") === null || field(node, "arguments") !== null) {
-    return false;
-  }
-  return calleeMethodName(node) !== "call";
-}
-function isRaise2(node) {
-  const method = field(node, "method") ?? children2(node)[0] ?? null;
-  return field(node, "receiver") === null && method !== null && RAISE_NAMES2.has(method.text);
-}
-var NO_INHERITED_METHODS = /* @__PURE__ */ new Set();
-function isInherited(node, inherited) {
-  const method = field(node, "method");
-  return field(node, "receiver") === null && method !== null && inherited.has(method.text);
-}
-function isCall(node, locals, inherited) {
-  if (node.type === "call") {
-    return !isPropertyRead2(node) && !isRaise2(node) && !isInherited(node, inherited);
-  }
-  return isBareMethodCall(node, locals) && !RAISE_NAMES2.has(node.text) && !inherited.has(node.text);
-}
-function collectCalls(node, locals, inherited, found) {
-  for (const child of children2(node)) {
-    if (OWN_BODY_TYPES.has(child.type)) {
-      continue;
-    }
-    if (isCall(child, locals, inherited)) {
-      found.push(child);
-    }
-    collectCalls(child, locals, inherited, found);
-  }
-  return found;
-}
-function bodyCalls(definitionNode, inherited = NO_INHERITED_METHODS) {
-  const body = field(definitionNode, "body");
-  if (body === null) {
-    return [];
-  }
-  return collectCalls(body, localNamesIn(definitionNode), inherited, []);
-}
-function calleeText(call) {
-  const receiver = field(call, "receiver");
-  const method = calleeMethodName(call);
-  if (method === void 0) {
-    return call.text;
-  }
-  return receiver === null ? method : `${receiver.text}.${method}`;
-}
-function argOf(node) {
-  const literal = LITERAL_ARGS[node.type]?.(node);
-  if (literal !== null && literal !== void 0) {
-    return literal;
-  }
-  if (node.type === "call" && !isPropertyRead2(node)) {
-    return { kind: "call", callee: calleeText(node), args: argsOf(node) };
-  }
-  return { kind: "identifier", name: node.text };
-}
-function argsOf(call) {
-  const args = field(call, "arguments");
-  if (args === null) {
-    return [];
-  }
-  return children2(args).map(
-    (child) => child.type === "pair" ? argOf(field(child, "value") ?? child) : argOf(child)
-  );
-}
-function enclosingStatement(call, body) {
-  let current = call;
-  while (current.parent !== null) {
-    if (BLOCK_TYPES2.has(current.parent.type) || current.parent.id === body.id) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return current;
-}
-function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS) {
-  const body = field(definitionNode, "body");
-  if (body === null) {
-    return [];
-  }
-  const calls = withoutChainLinks(bodyCalls(definitionNode, inherited));
-  if (calls.length === 0) {
-    return [];
-  }
-  const statementOf2 = /* @__PURE__ */ new Map();
-  const statements = [];
-  for (const call of calls) {
-    const statement = enclosingStatement(call, body);
-    statementOf2.set(call.id, statement);
-    statements.push(statement);
-  }
-  const lowered = lowerRubyBody(body, statements);
-  const enumerated = (0, import_extractor4.enumerateOrDegrade)(
-    {
-      statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
-    },
-    statements
-  );
-  return calls.map((call) => {
-    const statement = statementOf2.get(call.id);
-    const conditions = (0, import_extractor4.sharedGatingConditions)(
-      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
-    );
-    return {
-      type: "invocation",
-      callee: calleeText(call),
-      args: argsOf(call),
-      async: false,
-      ...conditions.length > 0 ? { preconditions: conditions } : {}
-    };
-  });
-}
-
 // src/storage.ts
 var import_datalog2 = require("@suss/datalog");
 var import_ir_core = require("@suss/ir-core");
@@ -3266,6 +3653,16 @@ async function discoverUnits(root, options) {
     file: options.absoluteFile ?? options.filePath
   }));
   const units = [];
+  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 }
+        })
+      );
+    }
+  }
   for (const info of classes) {
     const ownBlocks = fileBlocks.filter(
       (block) => block.info.qualifiedName === info.qualifiedName
@@ -3297,7 +3694,7 @@ function unitsFor(pattern, pack, info, ownBlocks, fileBlocks, options) {
     graphqlObjectFields: (p) => graphqlObjectFieldUnits(p, pack, info, ownBlocks, fileBlocks, options),
     controllerActions: (p) => controllerActionUnits(p, pack, info, ownBlocks, fileBlocks, options)
   };
-  return (0, import_behavioral_ir2.dispatchByType)(table, pattern);
+  return (0, import_behavioral_ir3.dispatchByType)(table, pattern);
 }
 async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlocks, options) {
   if (info.bodyNode === null || pattern.baseClassNames.includes(info.qualifiedName)) {
@@ -3422,7 +3819,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       exportName: actionName,
       exportPath: [controllerQualifiedName, actionName]
     },
-    boundaryBinding: route === null ? null : (0, import_behavioral_ir2.restBinding)({
+    boundaryBinding: route === null ? null : (0, import_behavioral_ir3.restBinding)({
       transport: pack.protocol,
       method: route.method,
       path: route.path,
@@ -3540,7 +3937,7 @@ function bodyOfMethod(method, bodyRead = {}) {
   const storage = bodyRead.storage;
   const extra = [
     ...envReadEffects(method),
-    ...storage === void 0 ? [] : storageEffects(callsUnder(method), storage)
+    ...storage === void 0 ? [] : storageEffects(callsUnder2(method), storage)
   ];
   return {
     bodyContent: methodHasStatements(method) ? "statements" : "empty",
@@ -3549,7 +3946,7 @@ function bodyOfMethod(method, bodyRead = {}) {
     ...extra.length > 0 ? { extraEffects: extra } : {}
   };
 }
-function callsUnder(node, found = []) {
+function callsUnder2(node, found = []) {
   for (const child of node.namedChildren) {
     if (child === null) {
       continue;
@@ -3557,7 +3954,7 @@ function callsUnder(node, found = []) {
     if (child.type === "call") {
       found.push(child);
     }
-    callsUnder(child, found);
+    callsUnder2(child, found);
   }
   return found;
 }
@@ -3584,7 +3981,7 @@ function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
     ),
     none: () => nothingThere
   };
-  return (0, import_behavioral_ir2.dispatchByType)(table, found);
+  return (0, import_behavioral_ir3.dispatchByType)(table, found);
 }
 async function readFieldCall(stmt, scope, ctx, ancestry) {
   if (stmt.type !== "call" || field(stmt, "receiver") !== null) {
@@ -3853,7 +4250,7 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
       exportName: null,
       exportPath: null
     },
-    boundaryBinding: decl.namedOnTheWire ? (0, import_behavioral_ir2.graphqlResolverBinding)({
+    boundaryBinding: decl.namedOnTheWire ? (0, import_behavioral_ir3.graphqlResolverBinding)({
       transport: pack.protocol,
       recognition: pack.name,
       typeName,
@@ -4051,7 +4448,7 @@ function parseWith(language, source) {
 // src/project.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor10 = require("@suss/extractor");
 
@@ -4106,7 +4503,7 @@ function requiredRelativePath(node) {
 }
 
 // src/reach/closure.ts
-var import_behavioral_ir3 = require("@suss/behavioral-ir");
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
 var import_datalog3 = require("@suss/datalog");
 var import_extractor8 = require("@suss/extractor");
 
@@ -4330,14 +4727,14 @@ async function reachedFunctions(seeds, options) {
       gapHandling: "permissive"
     });
     summary.confidence = { source: "inferred_static", level: "low" };
-    summary.gaps.push(...(stopsByKey.get(key) ?? []).map(import_behavioral_ir3.unfollowedCallGap));
-    (0, import_behavioral_ir3.placeCalls)(summary, targetsByKey.get(key));
-    (0, import_behavioral_ir3.placeArgTargets)(summary, argTargetsByKey.get(key));
-    (0, import_behavioral_ir3.placeCalleeParameters)(summary, parameterCallsByKey.get(key));
+    summary.gaps.push(...(stopsByKey.get(key) ?? []).map(import_behavioral_ir4.unfollowedCallGap));
+    (0, import_behavioral_ir4.placeCalls)(summary, targetsByKey.get(key));
+    (0, import_behavioral_ir4.placeArgTargets)(summary, argTargetsByKey.get(key));
+    (0, import_behavioral_ir4.placeCalleeParameters)(summary, parameterCallsByKey.get(key));
     summariesByKey.set(key, [summary]);
     summaries.push(summary);
   }
-  (0, import_behavioral_ir3.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
+  (0, import_behavioral_ir4.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
   return {
     summaries,
     targetsByKey,
@@ -4447,7 +4844,7 @@ async function scanBody(source, ctx, options) {
   };
   const followed2 = [];
   const stops = [];
-  const placements = new import_behavioral_ir3.TargetPlacements();
+  const placements = new import_behavioral_ir4.TargetPlacements();
   const parameterCalls = [];
   const passedPositions = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -4500,7 +4897,7 @@ async function scanBody(source, ctx, options) {
     );
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.reason}:${callee}`;
-      if (!seen.has(stopKey) && (0, import_behavioral_ir3.worthRecording)(outcome.reason)) {
+      if (!seen.has(stopKey) && (0, import_behavioral_ir4.worthRecording)(outcome.reason)) {
         seen.add(stopKey);
         stops.push({ callee, reason: outcome.reason });
       }
@@ -4544,7 +4941,7 @@ function libraryUnit(target, options) {
       exportName: exportPath[0] ?? name,
       exportPath
     },
-    boundaryBinding: (0, import_behavioral_ir3.functionCallBinding)({
+    boundaryBinding: (0, import_behavioral_ir4.functionCallBinding)({
       transport: "in-process",
       recognition: "reachable"
     }),
@@ -4706,6 +5103,7 @@ async function extractRubyProject(options) {
         ...storagePatterns.length > 0 ? { storage: { facts: db, patterns: storagePatterns } } : {},
         inheritedMethods,
         displayPathOf,
+        facts: db,
         onReachSeed: (raw, seed) => seedByRaw.set(raw, seed)
       })
     );
@@ -4788,14 +5186,14 @@ async function extractRubyProject(options) {
   for (const [key, owners] of summariesBySeed) {
     for (const summary of owners) {
       summary.gaps.push(
-        ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir4.unfollowedCallGap)
+        ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir5.unfollowedCallGap)
       );
-      (0, import_behavioral_ir4.placeCalls)(summary, reached.targetsByKey.get(key));
-      (0, import_behavioral_ir4.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
-      (0, import_behavioral_ir4.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
+      (0, import_behavioral_ir5.placeCalls)(summary, reached.targetsByKey.get(key));
+      (0, import_behavioral_ir5.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
+      (0, import_behavioral_ir5.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
     }
   }
-  (0, import_behavioral_ir4.recordParameterGaps)(
+  (0, import_behavioral_ir5.recordParameterGaps)(
     reached.parameterCallsByKey,
     summariesBySeed,
     reached.passedPositions
@@ -4806,15 +5204,15 @@ async function extractRubyProject(options) {
   const idRoot = options.projectRoot ?? options.workspaceRoot;
   for (const summary of summaries) {
     const absoluteFile = options.workspaceRoot === void 0 ? summary.location.file : import_node_path4.default.resolve(options.workspaceRoot, summary.location.file);
-    summary.identity.id = (0, import_behavioral_ir4.summaryIdFromParts)({
+    summary.identity.id = (0, import_behavioral_ir5.summaryIdFromParts)({
       workspace: void 0,
       file: idRoot === void 0 ? absoluteFile : import_node_path4.default.relative(idRoot, absoluteFile),
       name: summary.identity.name,
       exportPath: summary.identity.exportPath
     });
   }
-  (0, import_behavioral_ir4.disambiguateSummaryIds)(summaries);
-  (0, import_behavioral_ir4.linkCallsToSummaries)(summaries);
+  (0, import_behavioral_ir5.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir5.linkCallsToSummaries)(summaries);
   const composed = timer.time(
     "summarize",
     () => (0, import_extractor10.composeWrappers)(summaries, {