@suss/adapter-ruby 0.23.0 → 0.24.0

package/dist/index.js

@@ -531,120 +531,16 @@ function inheritedStatements(ancestry, blockConfigures) {
 import {
   dispatchByType,
   graphqlResolverBinding,
-  restBinding
+  restBinding as restBinding2
 } from "@suss/behavioral-ir";
 import { absentReading as absentReading2, unreadableReading as unreadableReading2 } from "@suss/extractor";
 
-// src/envReads.ts
-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 DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
-function envReadEffects(root) {
-  const effects = [];
-  walkDescendants2(root, null, {
-    at: (node) => {
-      const read = envReadAt(node);
-      if (read !== null) {
-        effects.push(configReadEffect(read));
-      }
-    },
-    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? SKIP_CHILDREN2 : null
-  });
-  return effects;
-}
-function configReadEffect(read) {
-  return {
-    type: "interaction",
-    binding: 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;
-}
+// src/clientCalls.ts
+import { namesNothing, restBinding } from "@suss/behavioral-ir";
+import { pathOf } from "@suss/values";
 
-// src/responseStatus.ts
-import {
-  absentReading,
-  enumerateOrDegrade,
-  guardsHoldOn,
-  unreadableReading,
-  writtenReading
-} from "@suss/extractor";
-import { constantOf, literalOf as literalOf2 } from "@suss/values";
+// src/paths/effects.ts
+import { enumerateOrDegrade, sharedGatingConditions } from "@suss/extractor";
 
 // src/paths/bareCalls.ts
 var PARAMETER_LIST_TYPES = [
@@ -1020,9 +916,295 @@ function lowerRubyBody(body, terminals, responseCalls = []) {
   };
 }
 
+// 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 = enumerateOrDegrade(
+    {
+      statements: lowered.statements,
+      terminalsByStmt: lowered.terminalsByStmt
+    },
+    statements
+  );
+  return calls.map((call) => {
+    const statement = statementOf2.get(call.id);
+    const conditions = 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
+import {
+  absentReading,
+  enumerateOrDegrade as enumerateOrDegrade2,
+  guardsHoldOn,
+  unreadableReading,
+  writtenReading
+} from "@suss/extractor";
+import { constantOf, literalOf as literalOf3 } from "@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
 import { nodeOfKey } from "@suss/resolution";
-import { Evaluator, force, literalOf } from "@suss/values";
+import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
 
 // src/facts/resolve.ts
 import {
@@ -1088,7 +1270,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);
@@ -1102,7 +1284,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}`;
@@ -1130,7 +1312,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) {
@@ -1158,8 +1340,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"
   );
 }
@@ -1198,7 +1380,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");
@@ -1228,7 +1410,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",
@@ -1242,7 +1424,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;
     }
@@ -1256,7 +1438,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;
     }
@@ -1266,7 +1448,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);
@@ -1286,7 +1468,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];
@@ -1298,7 +1480,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);
@@ -1317,7 +1499,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;
@@ -1328,8 +1510,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));
       }
@@ -1373,13 +1555,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");
@@ -1421,7 +1603,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;
@@ -1452,7 +1634,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",
@@ -1958,7 +2140,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") {
@@ -1977,7 +2159,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") {
@@ -2031,7 +2213,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)
@@ -2367,6 +2549,18 @@ var calleeRows = [
     kind: "callee",
     origin: { module: "Kernel", name: "String" },
     apply: ({ args }) => ({ result: concat([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: concat([operand(args[0])]) })
+  },
+  {
+    kind: "callee",
+    origin: { module: "URI", name: "parse" },
+    apply: ({ args }) => ({ result: concat([operand(args[0])]) })
   }
 ];
 var rubyRows = [
@@ -2392,7 +2586,7 @@ function evaluatedValue(node, db) {
   return force(evaluatorFor(node, db).evaluate(node));
 }
 function stringValueOf(node, db) {
-  return literalOf(evaluatedValue(node, db));
+  return literalOf2(evaluatedValue(node, db));
 }
 function methodDefinitionsIn(file, root) {
   const found = /* @__PURE__ */ new Map();
@@ -2485,7 +2679,7 @@ function statusNumberOf(node, names) {
   if (typeof constant2 === "number") {
     return constant2;
   }
-  const name = literalOf2(value);
+  const name = literalOf3(value);
   return name === null ? null : names[name] ?? null;
 }
 function declarationsByName(declarations) {
@@ -2554,7 +2748,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
   };
@@ -2608,55 +2802,414 @@ function handsOnBranch(outcome, effects, extraEffects) {
     isDefault: outcome.conditions.length === 0
   };
 }
-function responseBranches(method, pattern, effects, extraEffects, options = {}) {
-  const declarations = pattern.responseStatusCalls ?? [];
-  const body = field(method, "body");
-  if (declarations.length === 0 || body === null) {
+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 = enumerateOrDegrade2(
+    {
+      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 = enumerateOrDegrade2(
+    {
+      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 ? 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: 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 : 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 = pathOf(evaluatedValue(written, options.facts));
+  return path7 === void 0 || 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: 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
+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 DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
+function envReadEffects(root) {
+  const effects = [];
+  walkDescendants2(root, null, {
+    at: (node) => {
+      const read = envReadAt(node);
+      if (read !== null) {
+        effects.push(configReadEffect(read));
+      }
+    },
+    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? SKIP_CHILDREN2 : null
+  });
+  return effects;
+}
+function configReadEffect(read) {
+  return {
+    type: "interaction",
+    binding: 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 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 = enumerateOrDegrade(
-    {
-      statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
-    },
-    terminals
+  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 ? 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: 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
@@ -2844,172 +3397,6 @@ function namesUnder(node) {
   return names;
 }
 
-// src/paths/effects.ts
-import { enumerateOrDegrade as enumerateOrDegrade2, sharedGatingConditions } from "@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 = enumerateOrDegrade2(
-    {
-      statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
-    },
-    statements
-  );
-  return calls.map((call) => {
-    const statement = statementOf2.get(call.id);
-    const conditions = 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
 import { deriveOnDemand as deriveOnDemand2, evaluate as evaluate2 } from "@suss/datalog";
 import { storageBinding } from "@suss/ir-core";
@@ -3232,6 +3619,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
@@ -3388,7 +3785,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       exportName: actionName,
       exportPath: [controllerQualifiedName, actionName]
     },
-    boundaryBinding: route === null ? null : restBinding({
+    boundaryBinding: route === null ? null : restBinding2({
       transport: pack.protocol,
       method: route.method,
       path: route.path,
@@ -3506,7 +3903,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",
@@ -3515,7 +3912,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;
@@ -3523,7 +3920,7 @@ function callsUnder(node, found = []) {
     if (child.type === "call") {
       found.push(child);
     }
-    callsUnder(child, found);
+    callsUnder2(child, found);
   }
   return found;
 }
@@ -4703,6 +5100,7 @@ async function extractRubyProject(options) {
         ...storagePatterns.length > 0 ? { storage: { facts: db, patterns: storagePatterns } } : {},
         inheritedMethods,
         displayPathOf,
+        facts: db,
         onReachSeed: (raw, seed) => seedByRaw.set(raw, seed)
       })
     );