@suss/adapter-typescript 0.8.0 → 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");
@@ -10066,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" ? {
@@ -10539,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") {
@@ -10611,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"],
@@ -10637,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;
@@ -10665,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)) {
@@ -10693,78 +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, scan) {
-  if (!import_ts_morph51.Node.isCallExpression(call)) {
+  if (!import_ts_morph52.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
-  const declarations = callee.getSymbol()?.getDeclarations() ?? [];
+  const symbol = callee.getSymbol();
+  const declarations = symbol?.getDeclarations() ?? [];
   for (const decl of declarations) {
     const resolved = resolveDecl(decl, calleeName);
     if (resolved !== null) {
-      return resolved;
+      return { kind: "followed", candidate: resolved };
     }
   }
-  if (scan.resolveCallable === void 0 || !readsAField(callee)) {
-    return null;
-  }
-  if (!declarations.some(isDeclaredShape)) {
-    return null;
-  }
-  const value = scan.resolveCallable(callee, scan.reachedFrom);
-  return value === null ? null : resolveDecl(value, calleeName);
-}
-function readsAField(callee) {
-  if (!import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
-    return false;
-  }
-  let receiver = callee.getExpression();
-  while (import_ts_morph51.Node.isPropertyAccessExpression(receiver)) {
-    receiver = receiver.getExpression();
+  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 import_ts_morph51.Node.isThisExpression(receiver);
-}
-function isDeclaredShape(declaration) {
-  return (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+  return {
+    kind: "stopped",
+    stop: {
+      callee: calleeName,
+      reason: classifyStop(declarationsBehind(symbol))
+    }
+  };
 }
 function collectReachable(func, scan) {
-  const found = [];
+  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, scan);
-    if (resolved === null) {
+    const calleeText = normalizeCallee(node.getExpression().getText());
+    const outcome = resolveCallee(node, calleeText, scan);
+    if (outcome === null) {
       return;
     }
-    const key = nodeKey2(resolved.func);
+    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(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 = {
@@ -10804,6 +10888,8 @@ 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);
@@ -10812,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]);
     }
   }
@@ -10832,7 +10919,11 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
         ...recognizers.resolveCallable === void 0 ? {} : { resolveCallable: recognizers.resolveCallable },
         ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
       };
-      for (const candidate of collectReachable(source.func, scan)) {
+      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);
@@ -10863,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)(
@@ -11009,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) {
@@ -11019,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;
     }
   });
@@ -11029,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();
@@ -11043,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);
@@ -11067,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();
@@ -11093,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;
     }
   }
@@ -11106,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) {
@@ -11142,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);
@@ -11178,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") {
@@ -11210,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];
@@ -11225,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;
@@ -11239,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();
   }
@@ -11266,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);
       }
     });
@@ -11286,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());
@@ -11298,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();
     }
@@ -11318,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();
@@ -11389,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();
@@ -11451,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,
@@ -11464,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;
     }
@@ -11478,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 {
@@ -11512,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);
     }
   });
@@ -11527,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;
@@ -11549,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;
     }
   }
@@ -11578,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;
@@ -11590,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()];
@@ -11813,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());
@@ -11830,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 [
       {
@@ -11956,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();
@@ -11969,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,
@@ -12237,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);
@@ -12368,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";
@@ -12818,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);
@@ -12846,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);
@@ -12891,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;
     }
   }
@@ -12909,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;
     }
@@ -12923,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();
@@ -12931,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())}}`;
@@ -12948,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();
     }
   }
@@ -13059,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
@@ -13402,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",
@@ -13450,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,
@@ -13495,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) {
@@ -13543,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
@@ -13662,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 = {}) {
@@ -13691,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 });
@@ -13719,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();
@@ -13730,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);
   }
@@ -13770,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);
@@ -13786,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());
@@ -13804,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);
@@ -13819,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);
@@ -13846,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;
@@ -13875,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) {
@@ -13887,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;