@suss/adapter-typescript 0.7.2 → 0.9.0

package/dist/index.cjs

@@ -63,7 +63,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path9 = __toESM(require("path"), 1);
-var import_ts_morph55 = require("ts-morph");
+var import_ts_morph56 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor5 = require("@suss/extractor");
@@ -3985,6 +3985,7 @@ var import_ts_morph19 = require("ts-morph");
 var import_ts_morph18 = require("ts-morph");
 var byFile = createPerFileCache();
 var byDeclaration = /* @__PURE__ */ new WeakMap();
+var byField = /* @__PURE__ */ new WeakMap();
 function writesToBinding(declaration) {
   const remembered = byDeclaration.get(declaration);
   if (remembered !== void 0) {
@@ -4017,22 +4018,19 @@ function writesToBindingUncached(declaration) {
   return { values, inOrder: writesRunInOrder(declaration, writes) };
 }
 function writesToField(declaration) {
-  const remembered = byDeclaration.get(declaration);
+  const remembered = byField.get(declaration);
   if (remembered !== void 0) {
     return remembered;
   }
   const answer = writesToFieldUncached(declaration);
-  byDeclaration.set(declaration, answer);
+  byField.set(declaration, answer);
   return answer;
 }
 function writesToFieldUncached(declaration) {
-  const initializer = declaration.getInitializer();
+  const first = startingValueOf(declaration);
   const assignments = assignmentsTo(declaration);
   if (assignments.length === 0) {
-    return {
-      values: initializer === void 0 ? [] : [initializer],
-      inOrder: true
-    };
+    return { values: first === void 0 ? [] : [first], inOrder: true };
   }
   const values = [];
   for (const write of assignments) {
@@ -4041,14 +4039,16 @@ function writesToFieldUncached(declaration) {
     }
     values.push(write.value);
   }
-  const withInitializer = initializer === void 0 ? values : [initializer, ...values];
   return {
-    values: withInitializer,
+    values: first === void 0 ? values : [first, ...values],
     inOrder: assignments.every(
       (write) => writeRunsInConstructor(declaration, write)
     )
   };
 }
+function startingValueOf(declaration) {
+  return import_ts_morph18.Node.isParameterDeclaration(declaration) ? declaration : declaration.getInitializer();
+}
 function writeRunsInConstructor(declaration, write) {
   const statement = statementOf(write.node);
   if (statement === null) {
@@ -4059,13 +4059,16 @@ function writeRunsInConstructor(declaration, write) {
     return false;
   }
   const owner = body.getParent();
-  return owner !== void 0 && import_ts_morph18.Node.isConstructorDeclaration(owner) && owner.getParent() === declaration.getParent();
+  return owner !== void 0 && import_ts_morph18.Node.isConstructorDeclaration(owner) && owner.getParent() === classHolding(declaration);
+}
+function classHolding(declaration) {
+  return import_ts_morph18.Node.isParameterDeclaration(declaration) ? declaration.getParent().getParent() : declaration.getParent();
 }
 function isWrittenAgain(declaration) {
   return assignmentsTo(declaration).length > 0;
 }
 function assignmentsTo(declaration) {
-  if (import_ts_morph18.Node.isPropertyDeclaration(declaration)) {
+  if (import_ts_morph18.Node.isPropertyDeclaration(declaration) || import_ts_morph18.Node.isParameterDeclaration(declaration)) {
     const sourceFile2 = declaration.getSourceFile();
     return sourceFile2.isDeclarationFile() ? [] : assignmentsInFile(sourceFile2).get(declaration) ?? [];
   }
@@ -4132,7 +4135,9 @@ function declarationsOf(name) {
   }
   const declarations = [];
   for (const declaration of symbol.getDeclarations()) {
-    if (import_ts_morph18.Node.isVariableDeclaration(declaration) || import_ts_morph18.Node.isPropertyDeclaration(declaration)) {
+    if (import_ts_morph18.Node.isVariableDeclaration(declaration) || import_ts_morph18.Node.isPropertyDeclaration(declaration) || // A parameter property is the field's only declaration, so
+    // `this.dao = other` in the constructor writes to it.
+    import_ts_morph18.Node.isParameterDeclaration(declaration) && declaration.isParameterProperty()) {
       declarations.push(declaration);
     }
   }
@@ -5909,7 +5914,8 @@ function createNodeTable() {
     byId: /* @__PURE__ */ new Map(),
     seenFunctions: /* @__PURE__ */ new Set(),
     seenBindings: /* @__PURE__ */ new Set(),
-    seenValues: /* @__PURE__ */ new Set()
+    seenValues: /* @__PURE__ */ new Set(),
+    seenClasses: /* @__PURE__ */ new Set()
   };
 }
 function nodeId(node) {
@@ -6130,7 +6136,7 @@ function emitValue(db, table, value) {
     }
     return id;
   }
-  if (import_ts_morph28.Node.isCallExpression(expression)) {
+  if (import_ts_morph28.Node.isCallExpression(expression) || import_ts_morph28.Node.isNewExpression(expression)) {
     emitCallFacts(db, table, expression);
     fact(db, "writtenValue", id);
     return id;
@@ -6157,11 +6163,24 @@ function emitBindingValues(db, table, declaration) {
 function emitFieldValues(db, table, declaration) {
   const { values, inOrder } = writesToField(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0) {
+  if (!inOrder || last === void 0 || !import_ts_morph28.Node.isExpression(last)) {
     return;
   }
   fact(db, "binds", nodeId(declaration), emitValue(db, table, last));
 }
+function emitParameterPropertyRead(db, table, referenceId, declaration) {
+  const { values, inOrder } = writesToField(declaration);
+  const last = values[values.length - 1];
+  if (!inOrder || last === void 0) {
+    return;
+  }
+  if (!import_ts_morph28.Node.isExpression(last)) {
+    table.byId.set(nodeId(last), last);
+    fact(db, "binds", referenceId, nodeId(last));
+    return;
+  }
+  fact(db, "binds", referenceId, emitValue(db, table, last));
+}
 function emitBindingElementFacts(db, table, element) {
   const id = nodeId(element);
   table.byId.set(id, element);
@@ -6243,7 +6262,16 @@ function emitReferenceFacts(db, table, reference) {
       continue;
     }
     if (import_ts_morph28.Node.isParameterDeclaration(declaration)) {
+      if (declaration.isParameterProperty() && import_ts_morph28.Node.isPropertyAccessExpression(reference)) {
+        emitParameterPropertyRead(db, table, referenceId, declaration);
+      } else {
+        fact(db, "binds", referenceId, declarationId);
+      }
+      continue;
+    }
+    if (import_ts_morph28.Node.isClassDeclaration(declaration)) {
       fact(db, "binds", referenceId, declarationId);
+      emitClassFacts(db, table, declaration);
       continue;
     }
     if (import_ts_morph28.Node.isBindingElement(declaration)) {
@@ -6288,9 +6316,14 @@ function emitCallFacts(db, table, call) {
   }
 }
 function emitClassFacts(db, table, declaration) {
+  if (table.seenClasses.has(declaration)) {
+    return;
+  }
+  table.seenClasses.add(declaration);
   const id = nodeId(declaration);
   table.byId.set(id, declaration);
   fact(db, "objectValue", id);
+  emitConstructorParameters(db, table, declaration, id);
   for (const method of declaration.getMethods()) {
     const methodId = nodeId(method);
     table.byId.set(methodId, method);
@@ -6311,6 +6344,25 @@ function emitClassFacts(db, table, declaration) {
     }
   }
 }
+function emitConstructorParameters(db, table, declaration, classId) {
+  const implementation = declaration.getConstructors().find((candidate) => candidate.getBody() !== void 0);
+  if (implementation === void 0) {
+    return;
+  }
+  emitParameters(db, table, classId, implementation.getParameters());
+}
+function emitParameters(db, table, ownerId, parameters) {
+  for (let position = 0; position < parameters.length; position++) {
+    const parameter = parameters[position];
+    if (parameter === void 0) {
+      continue;
+    }
+    const parameterId = nodeId(parameter);
+    table.byId.set(parameterId, parameter);
+    fact(db, "paramOf", ownerId, String(position), parameterId);
+    fact(db, "paramNamed", ownerId, parameter.getName(), parameterId);
+  }
+}
 function emitFunctionFacts(db, table, fn) {
   if (table.seenFunctions.has(fn)) {
     return;
@@ -6319,17 +6371,7 @@ function emitFunctionFacts(db, table, fn) {
   const fnId = nodeId(fn);
   table.byId.set(fnId, fn);
   if (import_ts_morph28.Node.isFunctionDeclaration(fn) || import_ts_morph28.Node.isFunctionExpression(fn) || import_ts_morph28.Node.isArrowFunction(fn) || import_ts_morph28.Node.isMethodDeclaration(fn)) {
-    const parameters = fn.getParameters();
-    for (let position = 0; position < parameters.length; position++) {
-      const parameter = parameters[position];
-      if (parameter === void 0) {
-        continue;
-      }
-      const parameterId = nodeId(parameter);
-      table.byId.set(parameterId, parameter);
-      fact(db, "paramOf", fnId, String(position), parameterId);
-      fact(db, "paramNamed", fnId, parameter.getName(), parameterId);
-    }
+    emitParameters(db, table, fnId, fn.getParameters());
     const body = fn.getBody?.();
     if (body !== void 0) {
       if (import_ts_morph28.Node.isExpression(body)) {
@@ -10024,11 +10066,12 @@ var import_ts_morph50 = require("ts-morph");
 var import_datalog2 = require("@suss/datalog");
 var import_resolution = require("@suss/resolution");
 var JS_RULES = [
-  // f.bind(...) resolves to whatever f resolves to.
+  // f.bind(...) leads wherever f leads. Stated as a step, so the
+  // questions other than `comesTo` follow it too.
   (0, import_datalog2.rule)(
-    "comesTo",
-    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("h")],
-    [(0, import_datalog2.lit)("bindCall", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t")), (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("t"), (0, import_datalog2.variable)("h"))]
+    "stepsTo",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t"), import_resolution.VALUE_STEP],
+    [(0, import_datalog2.lit)("bindCall", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t"))]
   )
 ];
 var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
@@ -10055,9 +10098,21 @@ var ResolutionStore = class {
       this.db.add("wrapperModule", [wrapper.callee, wrapper.module]);
     }
   }
-  resolveCallable(value) {
+  /**
+   * `alsoFrom` is a second file to walk out from, for a caller that
+   * knows where the value it is asking about was set up. The walk
+   * follows imports outward from the value's own file, so a file that
+   * imports it, and passed something to the constructor, is somewhere
+   * the walk never reaches on its own.
+   */
+  resolveCallable(value, alsoFrom) {
     const target = factKeyOf(value);
-    return this.resolveByWaves(target, "wanted", () => this.lookup(target));
+    return this.resolveByWaves(
+      target,
+      "wanted",
+      () => this.lookup(target),
+      alsoFrom
+    );
   }
   resolveObject(value) {
     const target = factKeyOf(value);
@@ -10125,18 +10180,18 @@ var ResolutionStore = class {
     }
     return origins.some((pair) => namesAPackage(pairHalves(pair).module)) ? [] : null;
   }
-  resolveByWaves(value, question, ask) {
+  resolveByWaves(value, question, ask, alsoFrom) {
     try {
-      return this.walkForAnswer(value, question, ask);
+      return this.walkForAnswer(value, question, ask, alsoFrom);
     } finally {
       this.forgetQuery();
     }
   }
-  walkForAnswer(value, question, ask) {
+  walkForAnswer(value, question, ask, alsoFrom) {
     this.wantValue(question, value);
     this.seedValue(value);
     const walked = /* @__PURE__ */ new Set();
-    let frontier = [value.getSourceFile()];
+    let frontier = alsoFrom === void 0 ? [value.getSourceFile()] : [value.getSourceFile(), alsoFrom];
     for (let hop = 0; hop <= MAX_MODULE_HOPS; hop++) {
       const next = [];
       for (const sourceFile of frontier) {
@@ -10485,7 +10540,10 @@ function bindingLabel(binding) {
   if (semantics.name === "graphql-operation") {
     return `${semantics.operationType} ${semantics.operationName ?? ""}`.trim();
   }
-  return semantics.exportName ?? semantics.module ?? binding.recognition;
+  if ("exportName" in semantics || "module" in semantics) {
+    return semantics.exportName ?? semantics.module ?? binding.recognition;
+  }
+  return binding.recognition;
 }
 function effectFact(effect) {
   if (effect.type === "invocation") {
@@ -10557,10 +10615,100 @@ function deriveBoundaryEffects(summaries, facts) {
 }
 
 // src/resolve/reachableClosure.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
+
+// src/resolve/unfollowedCall.ts
+var import_ts_morph51 = require("ts-morph");
+function isInExternalCode(sourceFile) {
+  if (sourceFile.isDeclarationFile()) {
+    return true;
+  }
+  return sourceFile.getFilePath().includes("/node_modules/");
+}
+function hasBody(fn) {
+  if (import_ts_morph51.Node.isFunctionDeclaration(fn) || import_ts_morph51.Node.isMethodDeclaration(fn) || import_ts_morph51.Node.isFunctionExpression(fn)) {
+    return fn.getBody?.() !== void 0;
+  }
+  return true;
+}
+function isDeclaredShape(declaration) {
+  return (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+}
+function isExternalDeclaration(declaration) {
+  if (isInExternalCode(declaration.getSourceFile())) {
+    return true;
+  }
+  if (import_ts_morph51.Node.isImportSpecifier(declaration) || import_ts_morph51.Node.isImportClause(declaration) || import_ts_morph51.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph51.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    return target === void 0 || isInExternalCode(target);
+  }
+  return declaresAnotherModule(declaration);
+}
+function declaresAnotherModule(declaration) {
+  const module2 = declaration.getFirstAncestorByKind(
+    import_ts_morph51.SyntaxKind.ModuleDeclaration
+  );
+  return module2 !== void 0 && import_ts_morph51.Node.isStringLiteral(module2.getNameNode());
+}
+function statesShapeOnly(declaration) {
+  if (isExternalDeclaration(declaration)) {
+    return false;
+  }
+  if (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) {
+    return true;
+  }
+  if (import_ts_morph51.Node.isFunctionDeclaration(declaration) || import_ts_morph51.Node.isMethodDeclaration(declaration)) {
+    return declaration.getBody() === void 0;
+  }
+  return false;
+}
+function declarationsBehind(symbol) {
+  if (symbol === void 0) {
+    return [];
+  }
+  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
+  return behind.length > 0 ? behind : symbol.getDeclarations();
+}
+function classifyStop(declarations) {
+  if (declarations.length === 0) {
+    return "noDeclaration";
+  }
+  if (declarations.every(isExternalDeclaration)) {
+    return "outsideRun";
+  }
+  if (declarations.some(statesShapeOnly)) {
+    return "noBody";
+  }
+  return "unsettledValue";
+}
+var RECORDED = {
+  noBody: true,
+  unsettledValue: true,
+  outsideRun: false,
+  noDeclaration: false
+};
+function worthRecording(reason) {
+  return RECORDED[reason];
+}
+var STOP_SENTENCE = {
+  noBody: (callee) => `The call to ${callee} lands on a declaration with no body, so whatever runs there is missing from this summary`,
+  unsettledValue: (callee) => `The call to ${callee} goes through a value this run could not settle, so whatever runs there is missing from this summary`,
+  outsideRun: (callee) => `The call to ${callee} lands in a package whose source is not in this run, so whatever runs there is missing from this summary`,
+  noDeclaration: (callee) => `The call to ${callee} has no declaration this run could find, so whatever runs there is missing from this summary`
+};
+function unfollowedCallGap(stop) {
+  return {
+    type: "unfollowedCall",
+    conditions: [],
+    consequence: "unknown",
+    description: STOP_SENTENCE[stop.reason](stop.callee)
+  };
+}
+
+// src/resolve/reachableClosure.ts
 var reachablePack = {
   name: "reachable",
   languages: ["typescript"],
@@ -10583,23 +10731,6 @@ function nodeKey2(func) {
   const sf = func.getSourceFile();
   return `${sf.getFilePath()}:${func.getStart()}-${func.getEnd()}`;
 }
-function isInExternalCode(sourceFile) {
-  if (sourceFile.isDeclarationFile()) {
-    return true;
-  }
-  const filePath = sourceFile.getFilePath();
-  if (filePath.includes("/node_modules/")) {
-    return true;
-  }
-  return false;
-}
-function hasBody(fn) {
-  if (import_ts_morph51.Node.isFunctionDeclaration(fn) || import_ts_morph51.Node.isMethodDeclaration(fn) || import_ts_morph51.Node.isFunctionExpression(fn)) {
-    const body = fn.getBody?.();
-    return body !== void 0;
-  }
-  return true;
-}
 function resolveDecl(decl, calleeName) {
   if (isInExternalCode(decl.getSourceFile())) {
     return null;
@@ -10611,14 +10742,14 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph51.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph52.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph51.Node.isArrowFunction(init) || import_ts_morph51.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph52.Node.isArrowFunction(init) || import_ts_morph52.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
   }
-  if (import_ts_morph51.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph52.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sf = importDecl.getModuleSpecifierSourceFile();
     if (sf === void 0 || isInExternalCode(sf)) {
@@ -10639,61 +10770,85 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph51.Node.isFunctionDeclaration(decl) || import_ts_morph51.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph52.Node.isFunctionDeclaration(decl) || import_ts_morph52.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph51.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph52.Node.isFunctionExpression(decl)) {
     const n = decl.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
   const parent = decl.getParent();
-  if (parent !== void 0 && import_ts_morph51.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph52.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
 }
-function resolveCallee(call, calleeName) {
-  if (!import_ts_morph51.Node.isCallExpression(call)) {
+function resolveCallee(call, calleeName, scan) {
+  if (!import_ts_morph52.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
   const symbol = callee.getSymbol();
-  if (symbol === void 0) {
-    return null;
-  }
-  for (const decl of symbol.getDeclarations()) {
+  const declarations = symbol?.getDeclarations() ?? [];
+  for (const decl of declarations) {
     const resolved = resolveDecl(decl, calleeName);
     if (resolved !== null) {
-      return resolved;
+      return { kind: "followed", candidate: resolved };
     }
   }
-  return null;
+  const resolveCallable = scan.resolveCallable;
+  if (resolveCallable !== void 0 && import_ts_morph52.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+    const value = resolveCallable(callee, scan.reachedFrom);
+    const resolved = value === null ? null : resolveDecl(value, calleeName);
+    if (resolved !== null) {
+      return { kind: "followed", candidate: resolved };
+    }
+  }
+  return {
+    kind: "stopped",
+    stop: {
+      callee: calleeName,
+      reason: classifyStop(declarationsBehind(symbol))
+    }
+  };
 }
-function collectReachable(func) {
-  const found = [];
+function collectReachable(func, scan) {
+  const candidates = [];
+  const stops = [];
   const seen = /* @__PURE__ */ new Set();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph51.Node.isCallExpression(node)) {
+    if (!import_ts_morph52.Node.isCallExpression(node)) {
       return;
     }
-    const calleeText = node.getExpression().getText();
-    const resolved = resolveCallee(node, calleeText);
-    if (resolved === null) {
+    const calleeText = normalizeCallee(node.getExpression().getText());
+    const outcome = resolveCallee(node, calleeText, scan);
+    if (outcome === null) {
+      return;
+    }
+    if (outcome.kind === "stopped") {
+      const stopKey = `${outcome.stop.reason}:${outcome.stop.callee}`;
+      if (!seen.has(stopKey) && worthRecording(outcome.stop.reason)) {
+        seen.add(stopKey);
+        stops.push(outcome.stop);
+      }
       return;
     }
-    const key = nodeKey2(resolved.func);
+    const key = nodeKey2(outcome.candidate.func);
     if (seen.has(key)) {
       return;
     }
     seen.add(key);
-    found.push(resolved);
+    candidates.push(outcome.candidate);
   });
-  return found;
+  return { candidates, stops };
+}
+function normalizeCallee(text) {
+  return text.replace(/\s+/g, " ").trim();
 }
 function extractReachableSummary(candidate, options, recognizers) {
   const unit = {
@@ -10733,6 +10888,9 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
   const functionByKey = /* @__PURE__ */ new Map();
   const seedKeys = /* @__PURE__ */ new Set();
   const scanned = /* @__PURE__ */ new Set();
+  const stopsByKey = /* @__PURE__ */ new Map();
+  const summariesByKey = /* @__PURE__ */ new Map();
+  const reachedFrom = /* @__PURE__ */ new Map();
   for (const seed of seeds) {
     const func = lookup.functionAt(seed.location);
     if (func !== null) {
@@ -10740,6 +10898,7 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       seedKeys.add(key);
       functionByKey.set(key, { func, name: seed.identity.name });
       facts?.unitKeyBySummary.set(seed, key);
+      rememberSummary(summariesByKey, key, seed);
       db.add("entry", [key]);
     }
   }
@@ -10755,11 +10914,23 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       if (source === void 0) {
         continue;
       }
-      for (const candidate of collectReachable(source.func)) {
+      const cameFrom = reachedFrom.get(key);
+      const scan = {
+        ...recognizers.resolveCallable === void 0 ? {} : { resolveCallable: recognizers.resolveCallable },
+        ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
+      };
+      const { candidates, stops } = collectReachable(source.func, scan);
+      if (stops.length > 0) {
+        stopsByKey.set(key, stops);
+      }
+      for (const candidate of candidates) {
         const calleeKey = nodeKey2(candidate.func);
         if (!functionByKey.has(calleeKey)) {
           functionByKey.set(calleeKey, candidate);
         }
+        if (!reachedFrom.has(calleeKey)) {
+          reachedFrom.set(calleeKey, source.func.getSourceFile());
+        }
         db.add("calls", [key, calleeKey]);
       }
     }
@@ -10783,13 +10954,30 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
     }
     const summary = extractReachableSummary(candidate, options, recognizers);
     facts?.unitKeyBySummary.set(summary, key);
+    rememberSummary(summariesByKey, key, summary);
     reached.push(summary);
   }
+  recordStops(stopsByKey, summariesByKey, options);
   return [...seeds, ...reached];
 }
+function rememberSummary(summariesByKey, key, summary) {
+  const bucket = summariesByKey.get(key) ?? [];
+  bucket.push(summary);
+  summariesByKey.set(key, bucket);
+}
+function recordStops(stopsByKey, summariesByKey, options) {
+  if (options?.gapHandling === "silent") {
+    return;
+  }
+  for (const [key, stops] of stopsByKey) {
+    for (const summary of summariesByKey.get(key) ?? []) {
+      summary.gaps.push(...stops.map(unfollowedCallGap));
+    }
+  }
+}
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 var import_datalog5 = require("@suss/datalog");
 var RETHROW_RULES = [
   (0, import_datalog5.rule)(
@@ -10929,7 +11117,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph52.Node.isThrowStatement(node)) {
+    if (!import_ts_morph53.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -10939,7 +11127,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph52.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph53.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -10949,13 +11137,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph52.Node.isCatchClause(current2)) {
+    if (import_ts_morph53.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph52.Node.isTryStatement(current2)) {
+    if (import_ts_morph53.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph52.Node.isFunctionDeclaration(current2) || import_ts_morph52.Node.isFunctionExpression(current2) || import_ts_morph52.Node.isArrowFunction(current2) || import_ts_morph52.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph53.Node.isFunctionDeclaration(current2) || import_ts_morph53.Node.isFunctionExpression(current2) || import_ts_morph53.Node.isArrowFunction(current2) || import_ts_morph53.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -10963,14 +11151,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph52.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph53.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph52.Node.isCallExpression(node)) {
+    if (!import_ts_morph53.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -10987,7 +11175,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph52.Node.isCallExpression(call)) {
+  if (!import_ts_morph53.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -11013,12 +11201,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph52.Node.isFunctionDeclaration(decl) || import_ts_morph52.Node.isFunctionExpression(decl) || import_ts_morph52.Node.isArrowFunction(decl) || import_ts_morph52.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph53.Node.isFunctionDeclaration(decl) || import_ts_morph53.Node.isFunctionExpression(decl) || import_ts_morph53.Node.isArrowFunction(decl) || import_ts_morph53.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph52.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph53.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph52.Node.isArrowFunction(init) || import_ts_morph52.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph53.Node.isArrowFunction(init) || import_ts_morph53.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -11026,22 +11214,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph53.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph54.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph53.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph54.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph53.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph54.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph53.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph54.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -11062,11 +11250,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph53.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph54.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph53.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph54.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -11098,7 +11286,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph53.Node.isCallExpression(node)) {
+  if (import_ts_morph54.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -11130,14 +11318,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph53.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph54.Node.isParameterDeclaration(decl)) {
     return null;
   }
   const base = prefixOfThenParam(decl, responseCall, depth + 1);
   return base === null ? null : [...base, ...chain.segments];
 }
 function firstCallbackParamName(callback) {
-  if (callback === void 0 || !(import_ts_morph53.Node.isArrowFunction(callback) || import_ts_morph53.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph54.Node.isArrowFunction(callback) || import_ts_morph54.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -11145,11 +11333,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph53.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph54.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap2(expr) {
   let node = expr;
-  while (import_ts_morph53.Node.isAwaitExpression(node) || import_ts_morph53.Node.isParenthesizedExpression(node) || import_ts_morph53.Node.isAsExpression(node)) {
+  while (import_ts_morph54.Node.isAwaitExpression(node) || import_ts_morph54.Node.isParenthesizedExpression(node) || import_ts_morph54.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -11159,15 +11347,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph53.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph54.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph53.Node.isExpression(expr) ? unwrap2(expr) : expr;
-  if (import_ts_morph53.Node.isCallExpression(node)) {
+  let node = import_ts_morph54.Node.isExpression(expr) ? unwrap2(expr) : expr;
+  if (import_ts_morph54.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph53.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph54.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -11186,16 +11374,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph53.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph54.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph53.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph54.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph53.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph54.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -11206,7 +11394,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph53.Node.isIdentifier(node)) {
+    if (!import_ts_morph54.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -11218,13 +11406,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph53.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph54.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph53.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph54.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -11238,15 +11426,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph53.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph54.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph53.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph54.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph53.Node.isFunctionLikeDeclaration(current2) || import_ts_morph53.Node.isVariableStatement(current2)) {
+    if (import_ts_morph54.Node.isFunctionLikeDeclaration(current2) || import_ts_morph54.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -11309,7 +11497,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph53.Node.isIfStatement(parent)) {
+    if (import_ts_morph54.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -11371,7 +11559,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -11384,7 +11572,7 @@ function createTsSubUnitContext() {
 }
 function skipNestedFunctions(parent) {
   return (node, traversal) => {
-    if (node !== parent && (import_ts_morph54.Node.isFunctionDeclaration(node) || import_ts_morph54.Node.isFunctionExpression(node) || import_ts_morph54.Node.isArrowFunction(node) || import_ts_morph54.Node.isMethodDeclaration(node))) {
+    if (node !== parent && (import_ts_morph55.Node.isFunctionDeclaration(node) || import_ts_morph55.Node.isFunctionExpression(node) || import_ts_morph55.Node.isArrowFunction(node) || import_ts_morph55.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return true;
     }
@@ -11398,18 +11586,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph54.Node.isJsxOpeningElement(node) && !import_ts_morph54.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph55.Node.isJsxOpeningElement(node) && !import_ts_morph55.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph54.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph55.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph54.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph55.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -11432,11 +11620,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph54.Node.isCallExpression(node)) {
+    if (!import_ts_morph55.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph54.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph55.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -11447,10 +11635,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrowFunction(expr) || import_ts_morph54.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph55.Node.isArrowFunction(expr) || import_ts_morph55.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph54.Node.isIdentifier(expr)) {
+  if (import_ts_morph55.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -11469,15 +11657,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph54.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph55.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph54.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph55.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph54.Node.isArrowFunction(init) || import_ts_morph54.Node.isFunctionExpression(init)) {
+    if (import_ts_morph55.Node.isArrowFunction(init) || import_ts_morph55.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -11498,7 +11686,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrowFunction(arg) || import_ts_morph54.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph55.Node.isArrowFunction(arg) || import_ts_morph55.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -11510,7 +11698,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph55.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -11733,13 +11921,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph55.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph56.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph55.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph56.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph55.Node.isOmittedExpression(element)) {
+      if (import_ts_morph56.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -11750,7 +11938,7 @@ function bindingPatternNames(nameNode) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph55.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph56.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -11876,11 +12064,11 @@ function extractParameters(func, inputMapping) {
 function extractDependencyCalls(func) {
   const results = [];
   func.forEachDescendant((node, traversal) => {
-    if (node !== func && (import_ts_morph55.Node.isFunctionDeclaration(node) || import_ts_morph55.Node.isFunctionExpression(node) || import_ts_morph55.Node.isArrowFunction(node) || import_ts_morph55.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph56.Node.isFunctionDeclaration(node) || import_ts_morph56.Node.isFunctionExpression(node) || import_ts_morph56.Node.isArrowFunction(node) || import_ts_morph56.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph55.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph56.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -11889,19 +12077,19 @@ function extractDependencyCalls(func) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph55.Node.isAwaitExpression(init)) {
+    if (import_ts_morph56.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph55.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph56.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph55.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph56.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph55.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph56.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -12157,9 +12345,9 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
   if (m.type === "fromArgumentProperty") {
     const args = callSite.callExpression.getArguments();
     const arg = args[m.position];
-    if (arg !== void 0 && import_ts_morph55.Node.isObjectLiteralExpression(arg)) {
+    if (arg !== void 0 && import_ts_morph56.Node.isObjectLiteralExpression(arg)) {
       const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && import_ts_morph55.Node.isPropertyAssignment(prop)) {
+      if (prop !== void 0 && import_ts_morph56.Node.isPropertyAssignment(prop)) {
         const init = prop.getInitializer();
         if (init !== void 0) {
           const value = stringValueOf(init, resolution);
@@ -12288,22 +12476,22 @@ function extractBindingPath(binding, callSite, pack, resolution) {
   return void 0;
 }
 function pathFromUrlNode(node) {
-  if (import_ts_morph55.Node.isStringLiteral(node)) {
+  if (import_ts_morph56.Node.isStringLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph55.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph56.Node.isNoSubstitutionTemplateLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph55.Node.isTemplateExpression(node)) {
+  if (import_ts_morph56.Node.isTemplateExpression(node)) {
     return pathFromTemplateUrl(node);
   }
   return void 0;
 }
 function placeholderName(expr) {
-  if (import_ts_morph55.Node.isIdentifier(expr)) {
+  if (import_ts_morph56.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph55.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph56.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return "param";
@@ -12738,7 +12926,7 @@ function expandWrapperCallers(summaries, project, options) {
       continue;
     }
     const binding = s.identity.boundaryBinding;
-    if (binding === null || binding.semantics.name !== "rest" || binding.semantics.method === null || binding.semantics.path !== null) {
+    if (binding === null || binding.semantics.name !== "rest" || binding.semantics.method === null) {
       continue;
     }
     lookup ??= createSourceFileLookup(project);
@@ -12766,11 +12954,21 @@ function findWrapperPathParam(summary, lookup) {
   if (func === null) {
     return null;
   }
-  const params = func.getParameters();
-  if (params.length === 0) {
+  const names = func.getParameters().map((p) => p.getName());
+  if (names.length === 0) {
     return null;
   }
-  return { func, pathParamPosition: 0 };
+  for (const call of func.getDescendantsOfKind(import_ts_morph56.SyntaxKind.CallExpression)) {
+    const first = call.getArguments()[0];
+    if (first === void 0 || !import_ts_morph56.Node.isIdentifier(first)) {
+      continue;
+    }
+    const at = names.indexOf(first.getText());
+    if (at !== -1) {
+      return { func, pathParamPosition: at };
+    }
+  }
+  return null;
 }
 function synthesizeCallerSummaries(wrapper, _project, options) {
   const nameNode = wrapperNameNode(wrapper.func);
@@ -12811,16 +13009,16 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(func) || import_ts_morph55.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph56.Node.isFunctionDeclaration(func) || import_ts_morph56.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph55.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph56.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph55.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph56.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph55.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph56.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -12829,10 +13027,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph55.Node.isCallExpression(current2)) {
+    if (import_ts_morph56.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph55.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph56.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -12843,7 +13041,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph55.Node.isFunctionDeclaration(current2) || import_ts_morph55.Node.isFunctionExpression(current2) || import_ts_morph55.Node.isArrowFunction(current2) || import_ts_morph55.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph56.Node.isFunctionDeclaration(current2) || import_ts_morph56.Node.isFunctionExpression(current2) || import_ts_morph56.Node.isArrowFunction(current2) || import_ts_morph56.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -12851,13 +13049,13 @@ function enclosingFunction(node) {
   return null;
 }
 function literalOrTemplate(arg) {
-  if (import_ts_morph55.Node.isStringLiteral(arg)) {
+  if (import_ts_morph56.Node.isStringLiteral(arg)) {
     return arg.getLiteralValue();
   }
-  if (import_ts_morph55.Node.isNoSubstitutionTemplateLiteral(arg)) {
+  if (import_ts_morph56.Node.isNoSubstitutionTemplateLiteral(arg)) {
     return arg.getLiteralValue();
   }
-  if (import_ts_morph55.Node.isTemplateExpression(arg)) {
+  if (import_ts_morph56.Node.isTemplateExpression(arg)) {
     let path11 = arg.getHead().getLiteralText();
     for (const span of arg.getTemplateSpans()) {
       path11 += `{${placeholderName(span.getExpression())}}`;
@@ -12868,13 +13066,13 @@ function literalOrTemplate(arg) {
   return void 0;
 }
 function callerName(func) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(func) || import_ts_morph55.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph56.Node.isFunctionDeclaration(func) || import_ts_morph56.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph55.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph56.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph55.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph56.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -12979,7 +13177,7 @@ function loadRunFiles(project, candidatePaths, timer) {
   return { sourceFiles, deep };
 }
 function createTypeScriptAdapter(config) {
-  const project = config.project ?? new import_ts_morph55.Project(
+  const project = config.project ?? new import_ts_morph56.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -13148,7 +13346,8 @@ function createTypeScriptAdapter(config) {
               tallies
             ),
             access: collectAccessRecognizers(config.frameworks, tallies),
-            resolveWrittenValue: (value) => resolution.resolveWrittenValue(value)
+            resolveWrittenValue: (value) => resolution.resolveWrittenValue(value),
+            resolveCallable: (value, alsoFrom) => resolution.resolveCallable(value, alsoFrom)
           }
         )
       ) : withSubUnits;
@@ -13321,7 +13520,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path10 = __toESM(require("path"), 1);
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -13369,12 +13568,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph56.Project({
+  const project = new import_ts_morph57.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph56.ScriptTarget.ES2022,
-      module: import_ts_morph56.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph56.ModuleResolutionKind.Bundler,
+      target: import_ts_morph57.ScriptTarget.ES2022,
+      module: import_ts_morph57.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph57.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -13414,10 +13613,10 @@ function findNearestTsconfig(startDir) {
 }
 
 // src/configuredCall.ts
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 function readConfiguredCall(call, ctx, spec) {
   const callee = call.getExpression();
-  if (!import_ts_morph57.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph58.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   if (callee.getName() !== spec.method) {
@@ -13462,10 +13661,10 @@ function readStringArg(arg) {
 }
 function rootIdentifier(node) {
   let current2 = node;
-  while (import_ts_morph57.Node.isPropertyAccessExpression(current2)) {
+  while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
     current2 = current2.getExpression();
   }
-  return import_ts_morph57.Node.isIdentifier(current2) ? current2 : null;
+  return import_ts_morph58.Node.isIdentifier(current2) ? current2 : null;
 }
 
 // src/packHealth.ts
@@ -13581,7 +13780,7 @@ function formatPackHealth(checks, audiences) {
 }
 
 // src/resolve/readName.ts
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -13610,25 +13809,25 @@ function read(expr, ctx) {
   }
   const seen = new Set(ctx.seen).add(expr);
   const inner = { ...ctx, seen };
-  if (import_ts_morph58.Node.isStringLiteral(expr) || import_ts_morph58.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph59.Node.isStringLiteral(expr) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.getLiteralValue();
   }
-  if (import_ts_morph58.Node.isNumericLiteral(expr)) {
+  if (import_ts_morph59.Node.isNumericLiteral(expr)) {
     return expr.getLiteralText();
   }
-  if (import_ts_morph58.Node.isTemplateExpression(expr)) {
+  if (import_ts_morph59.Node.isTemplateExpression(expr)) {
     return fromTemplate(expr, inner);
   }
-  if (import_ts_morph58.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph59.Node.isParenthesizedExpression(expr)) {
     return read(expr.getExpression(), inner);
   }
-  if (import_ts_morph58.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph59.Node.isBinaryExpression(expr)) {
     return fromBinary(expr, inner);
   }
-  if (import_ts_morph58.Node.isCallExpression(expr)) {
+  if (import_ts_morph59.Node.isCallExpression(expr)) {
     return fromCall(expr, inner);
   }
-  if (import_ts_morph58.Node.isIdentifier(expr)) {
+  if (import_ts_morph59.Node.isIdentifier(expr)) {
     const only = boundOnce(expr, ctx);
     if (only !== null) {
       return read(only.node, { ...inner, bindings: only.scope });
@@ -13638,7 +13837,7 @@ function read(expr, ctx) {
   return written === null || written === expr ? null : read(written, inner);
 }
 function fromTemplate(expr, ctx) {
-  if (!import_ts_morph58.Node.isTemplateExpression(expr)) {
+  if (!import_ts_morph59.Node.isTemplateExpression(expr)) {
     return null;
   }
   let name = expr.getHead().getLiteralText();
@@ -13649,28 +13848,28 @@ function fromTemplate(expr, ctx) {
   return name;
 }
 function fromBinary(expr, ctx) {
-  if (!import_ts_morph58.Node.isBinaryExpression(expr)) {
+  if (!import_ts_morph59.Node.isBinaryExpression(expr)) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === import_ts_morph58.SyntaxKind.BarBarToken || operator === import_ts_morph58.SyntaxKind.QuestionQuestionToken) {
+  if (operator === import_ts_morph59.SyntaxKind.BarBarToken || operator === import_ts_morph59.SyntaxKind.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== import_ts_morph58.SyntaxKind.PlusToken) {
+  if (operator !== import_ts_morph59.SyntaxKind.PlusToken) {
     return null;
   }
   const parts = { ...ctx, insideHole: true };
   return readOrHole(expr.getLeft(), parts) + readOrHole(expr.getRight(), parts);
 }
 function fromCall(expr, ctx) {
-  if (!import_ts_morph58.Node.isCallExpression(expr)) {
+  if (!import_ts_morph59.Node.isCallExpression(expr)) {
     return null;
   }
   const callee = expr.getExpression();
-  if (import_ts_morph58.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
+  if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
     return fromJoin(callee.getExpression(), expr.getArguments(), ctx);
   }
-  if (import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === "String") {
+  if (import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === "String") {
     const only = expr.getArguments()[0];
     return only === void 0 ? null : readOrHole(only, ctx);
   }
@@ -13689,7 +13888,7 @@ function fromCall(expr, ctx) {
 }
 function fromJoin(subject, args, ctx) {
   const separator = args[0];
-  if (separator === void 0 || !import_ts_morph58.Node.isStringLiteral(separator)) {
+  if (separator === void 0 || !import_ts_morph59.Node.isStringLiteral(separator)) {
     return null;
   }
   const parts = elementsOf(subject, ctx);
@@ -13705,17 +13904,17 @@ function fromJoin(subject, args, ctx) {
   ).join(separator.getLiteralValue());
 }
 function elementsOf(subject, ctx) {
-  if (import_ts_morph58.Node.isArrayLiteralExpression(subject)) {
+  if (import_ts_morph59.Node.isArrayLiteralExpression(subject)) {
     return subject.getElements().map((element) => here(element, ctx));
   }
-  if (import_ts_morph58.Node.isCallExpression(subject)) {
+  if (import_ts_morph59.Node.isCallExpression(subject)) {
     const callee = subject.getExpression();
-    if (import_ts_morph58.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
+    if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
       return elementsOf(callee.getExpression(), ctx);
     }
     return null;
   }
-  if (!import_ts_morph58.Node.isIdentifier(subject)) {
+  if (!import_ts_morph59.Node.isIdentifier(subject)) {
     return null;
   }
   const bound = ctx.bindings.get(subject.getText());
@@ -13723,7 +13922,7 @@ function elementsOf(subject, ctx) {
     return null;
   }
   const only = bound.length === 1 ? bound[0] : void 0;
-  return only !== void 0 && import_ts_morph58.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
+  return only !== void 0 && import_ts_morph59.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
 }
 function singleReturnBody(callee, ctx) {
   const declaration = declarationOf2(callee, ctx);
@@ -13738,22 +13937,22 @@ function singleReturnBody(callee, ctx) {
   if (body === void 0) {
     return null;
   }
-  if (import_ts_morph58.Node.isExpression(body)) {
+  if (import_ts_morph59.Node.isExpression(body)) {
     return { parameters, returned: body };
   }
-  if (!import_ts_morph58.Node.isBlock(body)) {
+  if (!import_ts_morph59.Node.isBlock(body)) {
     return null;
   }
   const statements = body.getStatements();
   const only = statements[0];
-  if (statements.length !== 1 || only === void 0 || !import_ts_morph58.Node.isReturnStatement(only)) {
+  if (statements.length !== 1 || only === void 0 || !import_ts_morph59.Node.isReturnStatement(only)) {
     return null;
   }
   const returned = only.getExpression();
   return returned === void 0 ? null : { parameters, returned };
 }
 function declarationOf2(callee, ctx) {
-  const symbol = import_ts_morph58.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
+  const symbol = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
   const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
   for (const declaration of declarations) {
     const callable = asCallable(declaration);
@@ -13765,14 +13964,14 @@ function declarationOf2(callee, ctx) {
   return written === null || written === callee ? null : declarationOf2(written, { ...ctx, resolve: () => null });
 }
 function asCallable(declaration) {
-  if (import_ts_morph58.Node.isFunctionDeclaration(declaration) || import_ts_morph58.Node.isMethodDeclaration(declaration) || import_ts_morph58.Node.isArrowFunction(declaration) || import_ts_morph58.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph59.Node.isFunctionDeclaration(declaration) || import_ts_morph59.Node.isMethodDeclaration(declaration) || import_ts_morph59.Node.isArrowFunction(declaration) || import_ts_morph59.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (!import_ts_morph58.Node.isVariableDeclaration(declaration)) {
+  if (!import_ts_morph59.Node.isVariableDeclaration(declaration)) {
     return null;
   }
   const initializer = declaration.getInitializer();
-  if (initializer !== void 0 && (import_ts_morph58.Node.isArrowFunction(initializer) || import_ts_morph58.Node.isFunctionExpression(initializer))) {
+  if (initializer !== void 0 && (import_ts_morph59.Node.isArrowFunction(initializer) || import_ts_morph59.Node.isFunctionExpression(initializer))) {
     return initializer;
   }
   return null;
@@ -13794,7 +13993,7 @@ function here(node, ctx) {
   return { node, scope: ctx.bindings };
 }
 function boundOnce(expr, ctx) {
-  const bound = import_ts_morph58.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
+  const bound = import_ts_morph59.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
   return bound !== void 0 && bound.length === 1 ? bound[0] : null;
 }
 function readOrHole(expr, ctx) {
@@ -13806,10 +14005,10 @@ function holeName(expr, ctx) {
   if (bound !== null) {
     return holeName(bound.node, { ...ctx, bindings: bound.scope });
   }
-  if (import_ts_morph58.Node.isIdentifier(expr)) {
+  if (import_ts_morph59.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph58.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph59.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return UNNAMED_HOLE;