@suss/adapter-typescript 0.26.0 → 0.27.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   GENERIC_TERMINALS: () => GENERIC_TERMINALS,
   NO_BARRIERS: () => NO_BARRIERS,
   ResolutionStore: () => ResolutionStore,
+  TSCONFIG_NAMES: () => TSCONFIG_NAMES,
   TypeScriptWhySession: () => TypeScriptWhySession,
   accessContextFor: () => accessContextFor,
   buildProjectHelperIndex: () => buildProjectHelperIndex,
@@ -78,13 +79,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path11 = __toESM(require("path"), 1);
-var import_ts_morph67 = require("ts-morph");
+var import_ts_morph68 = require("ts-morph");
 var import_behavioral_ir8 = require("@suss/behavioral-ir");
-var import_datalog6 = require("@suss/datalog");
+var import_datalog5 = require("@suss/datalog");
 var import_extractor12 = require("@suss/extractor");
 
 // src/assembly.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 var import_extractor5 = require("@suss/extractor");
 
 // src/conditions.ts
@@ -897,11 +898,11 @@ function tryExpandArrayIncludes(call) {
   return {
     type: "compound",
     op: "or",
-    operands: literalValues.map((lit6) => ({
+    operands: literalValues.map((lit5) => ({
       type: "comparison",
       left: subject,
       op: "eq",
-      right: lit6
+      right: lit5
     }))
   };
 }
@@ -1544,7 +1545,7 @@ function degradedResult(func, terminalNodes, reason) {
 }
 
 // src/resolve/invocationEffects.ts
-var import_ts_morph42 = require("ts-morph");
+var import_ts_morph43 = require("ts-morph");
 var import_extractor4 = require("@suss/extractor");
 
 // src/lines.ts
@@ -2028,7 +2029,8 @@ function readFileText(project, filePath) {
     return null;
   }
 }
-function parseTsconfig(tsConfigFilePath) {
+function parseTsconfig(tsConfigFilePath, seen = /* @__PURE__ */ new Set()) {
+  seen.add(tsConfigFilePath);
   const configFile = import_ts_morph10.ts.readConfigFile(tsConfigFilePath, import_ts_morph10.ts.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
@@ -2041,7 +2043,18 @@ function parseTsconfig(tsConfigFilePath) {
     void 0,
     tsConfigFilePath
   );
-  return { fileNames: parsed.fileNames, options: parsed.options };
+  if (parsed.fileNames.length > 0) {
+    return { fileNames: parsed.fileNames, options: parsed.options };
+  }
+  const referenced = (parsed.projectReferences ?? []).map((reference) => import_ts_morph10.ts.resolveProjectReferencePath(reference)).filter((referencePath) => !seen.has(referencePath));
+  const fileNames = [
+    ...new Set(
+      referenced.flatMap(
+        (referencePath) => parseTsconfig(referencePath, seen).fileNames
+      )
+    )
+  ];
+  return { fileNames, options: parsed.options };
 }
 async function selectCandidateFiles(allFiles, packs, options) {
   const ungatedExists = packs.some(packIsUngated);
@@ -2402,7 +2415,7 @@ function reportUnreadableExports(file) {
 }
 
 // src/resolve/callOps.ts
-var import_ts_morph41 = require("ts-morph");
+var import_ts_morph42 = require("ts-morph");
 
 // src/configuredCall.ts
 var import_ts_morph12 = require("ts-morph");
@@ -2460,10 +2473,10 @@ function rootIdentifier(node) {
 }
 
 // src/parameterReads.ts
-var import_ts_morph39 = require("ts-morph");
+var import_ts_morph40 = require("ts-morph");
 
 // src/resolve/functionBehind.ts
-var import_ts_morph38 = require("ts-morph");
+var import_ts_morph39 = require("ts-morph");
 
 // src/facts/store.ts
 var import_ts_morph16 = require("ts-morph");
@@ -5244,6 +5257,7 @@ function literalValueOf(value, resolution, isWanted) {
 }
 
 // src/discovery/clientCall.ts
+var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 function discoverClientCalls(sourceFile, match, kind, resolution) {
   const results = [];
   const isGlobal = match.importModule === "global";
@@ -5268,9 +5282,15 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
       if (callee.getText() === match.importName) {
         matched = true;
       }
+    } else if (isGlobal && import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
+      if (callee.getName() === match.importName && GLOBAL_OBJECTS.has(callee.getExpression().getText())) {
+        matched = true;
+      }
+    } else if (match.callable === true && isClientItself(callee, match, clientVarNames, resolution)) {
+      matched = true;
     } else if (import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
+      if (isClientItself(subject, match, clientVarNames, resolution)) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -5296,6 +5316,9 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   });
   return results;
 }
+function isClientItself(subject, match, clientVarNames, resolution) {
+  return import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution);
+}
 function clientReceiverCheckFor(sourceFile, match, resolution) {
   const localName = resolveImportedLocalName(
     sourceFile,
@@ -7717,7 +7740,7 @@ function discoverPackageImports(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/registrationCall.ts
-var import_ts_morph33 = require("ts-morph");
+var import_ts_morph35 = require("ts-morph");
 var import_resolution3 = require("@suss/resolution");
 
 // src/resolve/routePath.ts
@@ -7725,9 +7748,143 @@ var import_values4 = require("@suss/values");
 function pathFromArgument(arg, resolution) {
   return (0, import_values4.pathOf)(evaluatedValue(arg, resolution));
 }
+function pathFromProperty(arg, property, resolution) {
+  const record2 = evaluatedValue(arg, resolution);
+  if (record2.kind !== "record") {
+    return void 0;
+  }
+  const field = record2.fields.get(property);
+  return field === void 0 ? void 0 : (0, import_values4.pathOf)((0, import_values4.force)(field.value));
+}
+
+// src/discovery/wrapperFactory.ts
+var import_ts_morph34 = require("ts-morph");
+
+// src/resolve/unfollowedCall.ts
+var import_ts_morph33 = require("ts-morph");
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
+function isInExternalCode(sourceFile) {
+  if (sourceFile.isDeclarationFile()) {
+    return true;
+  }
+  return sourceFile.getFilePath().includes("/node_modules/");
+}
+function hasBody(fn) {
+  if (import_ts_morph33.Node.isFunctionDeclaration(fn) || import_ts_morph33.Node.isMethodDeclaration(fn) || import_ts_morph33.Node.isFunctionExpression(fn)) {
+    return fn.getBody?.() !== void 0;
+  }
+  return true;
+}
+function isDeclaredShape(declaration) {
+  return (import_ts_morph33.Node.isMethodSignature(declaration) || import_ts_morph33.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+}
+function isExternalDeclaration(declaration) {
+  if (isInExternalCode(declaration.getSourceFile())) {
+    return true;
+  }
+  if (import_ts_morph33.Node.isImportSpecifier(declaration) || import_ts_morph33.Node.isImportClause(declaration) || import_ts_morph33.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph33.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    return target === void 0 || isInExternalCode(target);
+  }
+  return declaresAnotherModule(declaration);
+}
+function declaresAnotherModule(declaration) {
+  const module2 = declaration.getFirstAncestorByKind(
+    import_ts_morph33.SyntaxKind.ModuleDeclaration
+  );
+  return module2 !== void 0 && import_ts_morph33.Node.isStringLiteral(module2.getNameNode());
+}
+function statesShapeOnly(declaration) {
+  if (isExternalDeclaration(declaration)) {
+    return false;
+  }
+  if (import_ts_morph33.Node.isMethodSignature(declaration) || import_ts_morph33.Node.isPropertySignature(declaration)) {
+    return true;
+  }
+  if (import_ts_morph33.Node.isFunctionDeclaration(declaration) || import_ts_morph33.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 isParameterOf(declaration, scanning) {
+  return import_ts_morph33.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
+}
+function parameterIndexOf(declarations, scanning) {
+  if (scanning === void 0) {
+    return void 0;
+  }
+  const params = scanning.getParameters();
+  for (const declaration of declarations) {
+    const index = params.findIndex((param) => param === declaration);
+    if (index !== -1) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function classifyStop(declarations, scanning) {
+  if (declarations.length === 0) {
+    return "noDeclaration";
+  }
+  for (const declaration of declarations) {
+    if (!isInExternalCode(declaration.getSourceFile())) {
+      recordFileDependency(declaration.getSourceFile().getFilePath());
+    }
+  }
+  if (scanning !== void 0 && declarations.some((declaration) => isParameterOf(declaration, scanning))) {
+    return "callerSupplied";
+  }
+  if (declarations.every(isExternalDeclaration)) {
+    return "outsideRun";
+  }
+  if (declarations.some(statesShapeOnly)) {
+    return "noBody";
+  }
+  return "unsettledValue";
+}
+
+// src/discovery/wrapperFactory.ts
+function factoryNameOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph34.Node.isCallExpression(written)) {
+    return void 0;
+  }
+  const callee = written.getExpression();
+  if (import_ts_morph34.Node.isIdentifier(callee)) {
+    return callee.getText();
+  }
+  if (import_ts_morph34.Node.isPropertyAccessExpression(callee)) {
+    return callee.getName();
+  }
+  return void 0;
+}
+function factoryStopOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph34.Node.isCallExpression(written)) {
+    return null;
+  }
+  const callee = factoryNameOf(targetArg);
+  if (callee === void 0) {
+    return null;
+  }
+  const reason = classifyStop(
+    declarationsBehind(written.getExpression().getSymbol())
+  );
+  if (!(0, import_behavioral_ir2.worthRecording)(reason)) {
+    return null;
+  }
+  return { callee, reason: "unresolvedWrapper" };
+}
 
 // src/discovery/registrationCall.ts
-function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, resolution, mountPrefixes, expandedElsewhere) {
+function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, resolution, mountPrefixes, expandedElsewhere, routeWrapperPattern) {
   const results = [];
   const registrationSubjects = registrationSubjectsOf(
     sourceFile,
@@ -7742,11 +7899,11 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph33.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -7783,12 +7940,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     const registrationSubjectId = nodeId(subjectNode);
     let foundObjectArg = false;
     for (const arg of args) {
-      if (!import_ts_morph33.Node.isObjectLiteralExpression(arg)) {
+      if (!import_ts_morph35.Node.isObjectLiteralExpression(arg)) {
         continue;
       }
       foundObjectArg = true;
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph33.Node.isMethodDeclaration(prop)) {
+        if (import_ts_morph35.Node.isMethodDeclaration(prop)) {
           results.push({
             func: prop,
             kind,
@@ -7797,7 +7954,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           });
           continue;
         }
-        if (!import_ts_morph33.Node.isPropertyAssignment(prop)) {
+        if (!import_ts_morph35.Node.isPropertyAssignment(prop)) {
           continue;
         }
         const propInit = prop.getInitializer();
@@ -7829,6 +7986,13 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
         mountPrefixes
       );
       if (handler !== null) {
+        const chain = routeWrapperPattern === void 0 ? null : routeChainOf(
+          args.slice(0, -1),
+          routeWrapperPattern,
+          methodName,
+          routeInfo,
+          resolution
+        );
         results.push({
           func: handler,
           kind,
@@ -7836,8 +8000,13 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           name: methodName,
           nameKind: "label",
           registrationSubjectId,
-          ...routeInfo !== null ? { routeInfo } : {}
+          ...routeInfo !== null ? { routeInfo } : {},
+          ...chain === null || chain.references.length === 0 ? {} : { routeWrappers: chain.references },
+          ...chain === null || chain.unfollowed.length === 0 ? {} : { routeUnfollowed: chain.unfollowed }
         });
+        if (chain !== null) {
+          results.push(...chain.units);
+        }
         return;
       }
       if (routeInfo !== null && lastArg !== void 0 && namesAParameter(lastArg)) {
@@ -7883,6 +8052,47 @@ function declinedRegistration(call, callee, methodName, kind, receiver, resoluti
     }
   ];
 }
+function routeChainOf(listed, pattern, methodName, routeInfo, resolution) {
+  const chain = { units: [], references: [], unfollowed: [] };
+  const anonymousLabels = /* @__PURE__ */ new Map();
+  for (const arg of listed) {
+    const elements = import_ts_morph35.Node.isArrayLiteralExpression(arg) ? arg.getElements() : [arg];
+    for (const element of elements) {
+      const target = functionValueOf(element, resolution);
+      if (target === null) {
+        const stop = factoryStopOf(element);
+        if (stop !== null) {
+          chain.unfollowed.push(stop);
+        }
+        continue;
+      }
+      const ownName = functionNameOrAnon(target);
+      const named2 = ownName !== "<anon>";
+      const label = factoryNameOf(element) ?? methodName;
+      const seen = anonymousLabels.get(label) ?? 0;
+      if (!named2) {
+        anonymousLabels.set(label, seen + 1);
+      }
+      const name = named2 ? ownName : routeWrapperLabel(label, routeInfo, element, seen);
+      chain.units.push({
+        func: target,
+        kind: pattern.kind,
+        name,
+        pattern,
+        ...named2 ? {} : { nameKind: "label" }
+      });
+      chain.references.push({
+        file: target.getSourceFile().getFilePath(),
+        name
+      });
+    }
+  }
+  return chain;
+}
+function routeWrapperLabel(label, routeInfo, element, seen) {
+  const where = routeInfo === null ? `L${element.getStartLineNumber()}` : `${routeInfo.method} ${routeInfo.path}`;
+  return seen === 0 ? `${label}@${where}` : `${label}@${where}#${seen + 1}`;
+}
 function withMountPrefix(routeInfo, subjectNode, mountPrefixes) {
   if (routeInfo === null || mountPrefixes === void 0) {
     return routeInfo;
@@ -7910,13 +8120,13 @@ function subjectNodeFor(subject, subjects, match, resolution) {
 }
 var NOT_A_ROUTABLE = { kind: "none" };
 function receiverOf(subject, subjects, match, resolution) {
-  if (import_ts_morph33.Node.isIdentifier(subject)) {
+  if (import_ts_morph35.Node.isIdentifier(subject)) {
     const known = subjects.get(subject.getText());
     if (known !== void 0) {
       return { kind: "routable", node: known };
     }
   }
-  if (resolution === void 0 || !(import_ts_morph33.Node.isIdentifier(subject) || import_ts_morph33.Node.isPropertyAccessExpression(subject))) {
+  if (resolution === void 0 || !(import_ts_morph35.Node.isIdentifier(subject) || import_ts_morph35.Node.isPropertyAccessExpression(subject))) {
     return NOT_A_ROUTABLE;
   }
   const construction = resolution.subjectConstructionOf(
@@ -7956,18 +8166,18 @@ function collectMethodsCalledOnCallResults(sourceFile) {
   const setToCalls = /* @__PURE__ */ new Set();
   const calledOn = /* @__PURE__ */ new Map();
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph33.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph35.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && import_ts_morph33.Node.isCallExpression(init)) {
+      if (init !== void 0 && import_ts_morph35.Node.isCallExpression(init)) {
         setToCalls.add(node.getName());
       }
       return;
     }
-    if (!import_ts_morph33.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee) || !import_ts_morph33.Node.isIdentifier(callee.getExpression())) {
+    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee) || !import_ts_morph35.Node.isIdentifier(callee.getExpression())) {
       return;
     }
     const receiver = callee.getExpression().getText();
@@ -7994,18 +8204,18 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
     return subjects;
   }
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph33.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph35.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
       if (init === void 0) {
         return;
       }
-      const calleeText = import_ts_morph33.Node.isCallExpression(init) || import_ts_morph33.Node.isNewExpression(init) ? init.getExpression().getText() : null;
+      const calleeText = import_ts_morph35.Node.isCallExpression(init) || import_ts_morph35.Node.isNewExpression(init) ? init.getExpression().getText() : null;
       if (calleeText !== null && spellings.includes(calleeText)) {
         subjects.set(node.getName(), init);
       }
       return;
     }
-    if (!import_ts_morph33.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph35.Node.isParameterDeclaration(node)) {
       return;
     }
     const typeNode = node.getTypeNode();
@@ -8026,7 +8236,7 @@ function creationSiteBehind(parameter, resolution) {
     return parameter;
   }
   const written = resolution.resolveWrittenValue(parameter);
-  if (written === null || !(import_ts_morph33.Node.isCallExpression(written) || import_ts_morph33.Node.isNewExpression(written))) {
+  if (written === null || !(import_ts_morph35.Node.isCallExpression(written) || import_ts_morph35.Node.isNewExpression(written))) {
     return parameter;
   }
   return written;
@@ -8069,7 +8279,7 @@ function unboundConstructionsOf(sourceFile, importModule, importName) {
   }
   const constructions = [];
   sourceFile.forEachDescendant((node) => {
-    if ((import_ts_morph33.Node.isCallExpression(node) || import_ts_morph33.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph33.Node.isVariableDeclaration(node.getParent())) {
+    if ((import_ts_morph35.Node.isCallExpression(node) || import_ts_morph35.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph35.Node.isVariableDeclaration(node.getParent())) {
       constructions.push(node);
     }
   });
@@ -8087,11 +8297,11 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
   }
   const edges = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph33.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
+    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -8105,7 +8315,7 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
     }
     const args = node.getArguments();
     const prefixArg = args[mount.prefixPosition];
-    if (prefixArg === void 0 || !(import_ts_morph33.Node.isStringLiteral(prefixArg) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
+    if (prefixArg === void 0 || !(import_ts_morph35.Node.isStringLiteral(prefixArg) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
       return;
     }
     const targetNodes = mountTargetsAmong(
@@ -8160,7 +8370,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
   } else {
     const args = call.getArguments();
     const arg = args[binding.method.position];
-    if (arg === void 0 || !(import_ts_morph33.Node.isStringLiteral(arg) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(arg))) {
+    if (arg === void 0 || !(import_ts_morph35.Node.isStringLiteral(arg) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(arg))) {
       return null;
     }
     method = arg.getLiteralValue().toUpperCase();
@@ -8171,7 +8381,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
 }
 
 // src/discovery/registrationLoop.ts
-var import_ts_morph34 = require("ts-morph");
+var import_ts_morph36 = require("ts-morph");
 function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
   const results = [];
   const guard = receiverGuard(sourceFile, match.receiver, resolution);
@@ -8179,7 +8389,7 @@ function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isForOfStatement(node)) {
+    if (!import_ts_morph36.Node.isForOfStatement(node)) {
       return;
     }
     const expanded = tryExpandLoop(node, match, kind, resolution, guard);
@@ -8242,13 +8452,13 @@ function tryExpandLoop(loop, match, kind, resolution, guard) {
 }
 function loopVariableName(loop) {
   const initializer = loop.getInitializer();
-  if (import_ts_morph34.Node.isVariableDeclarationList(initializer)) {
+  if (import_ts_morph36.Node.isVariableDeclarationList(initializer)) {
     const decls = initializer.getDeclarations();
     if (decls.length !== 1) {
       return null;
     }
     const nameNode = decls[0]?.getNameNode();
-    if (nameNode !== void 0 && import_ts_morph34.Node.isIdentifier(nameNode)) {
+    if (nameNode !== void 0 && import_ts_morph36.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -8261,14 +8471,14 @@ function bodyReferencesLoopVar(loop, name) {
     if (referenced) {
       return;
     }
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph36.Node.isCallExpression(node)) {
       return;
     }
     node.forEachDescendant((inner) => {
       if (referenced) {
         return;
       }
-      if (import_ts_morph34.Node.isIdentifier(inner) && inner.getText() === name) {
+      if (import_ts_morph36.Node.isIdentifier(inner) && inner.getText() === name) {
         referenced = true;
       }
     });
@@ -8278,11 +8488,11 @@ function bodyReferencesLoopVar(loop, name) {
 function bodyCallsOnRoutable(loop, guard, resolution) {
   let found = false;
   loop.getStatement().forEachDescendant((node) => {
-    if (found || !import_ts_morph34.Node.isCallExpression(node)) {
+    if (found || !import_ts_morph36.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) && !import_ts_morph34.Node.isElementAccessExpression(callee)) {
+    if (!import_ts_morph36.Node.isPropertyAccessExpression(callee) && !import_ts_morph36.Node.isElementAccessExpression(callee)) {
       return;
     }
     const subject = callee.getExpression();
@@ -8302,11 +8512,11 @@ function readRouteSpec(element, shape, resolution) {
   let path15 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
-    if (import_ts_morph34.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
+    if (import_ts_morph36.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
       handler = { func: prop, name: shape.handlerKey };
       continue;
     }
-    if (!import_ts_morph34.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph36.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const name = prop.getName();
@@ -8329,111 +8539,19 @@ function readRouteSpec(element, shape, resolution) {
   return { method, path: path15, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
-  if (import_ts_morph34.Node.isStringLiteral(node) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph36.Node.isStringLiteral(node) || import_ts_morph36.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
 }
 function handlerName(value) {
-  return import_ts_morph34.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph36.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 
 // src/discovery/registrationTemplate.ts
 var import_node_path6 = __toESM(require("path"), 1);
-var import_ts_morph36 = require("ts-morph");
+var import_ts_morph37 = require("ts-morph");
 var import_resolution4 = require("@suss/resolution");
-
-// src/resolve/unfollowedCall.ts
-var import_ts_morph35 = require("ts-morph");
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
-function isInExternalCode(sourceFile) {
-  if (sourceFile.isDeclarationFile()) {
-    return true;
-  }
-  return sourceFile.getFilePath().includes("/node_modules/");
-}
-function hasBody(fn) {
-  if (import_ts_morph35.Node.isFunctionDeclaration(fn) || import_ts_morph35.Node.isMethodDeclaration(fn) || import_ts_morph35.Node.isFunctionExpression(fn)) {
-    return fn.getBody?.() !== void 0;
-  }
-  return true;
-}
-function isDeclaredShape(declaration) {
-  return (import_ts_morph35.Node.isMethodSignature(declaration) || import_ts_morph35.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
-}
-function isExternalDeclaration(declaration) {
-  if (isInExternalCode(declaration.getSourceFile())) {
-    return true;
-  }
-  if (import_ts_morph35.Node.isImportSpecifier(declaration) || import_ts_morph35.Node.isImportClause(declaration) || import_ts_morph35.Node.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(import_ts_morph35.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
-    return target === void 0 || isInExternalCode(target);
-  }
-  return declaresAnotherModule(declaration);
-}
-function declaresAnotherModule(declaration) {
-  const module2 = declaration.getFirstAncestorByKind(
-    import_ts_morph35.SyntaxKind.ModuleDeclaration
-  );
-  return module2 !== void 0 && import_ts_morph35.Node.isStringLiteral(module2.getNameNode());
-}
-function statesShapeOnly(declaration) {
-  if (isExternalDeclaration(declaration)) {
-    return false;
-  }
-  if (import_ts_morph35.Node.isMethodSignature(declaration) || import_ts_morph35.Node.isPropertySignature(declaration)) {
-    return true;
-  }
-  if (import_ts_morph35.Node.isFunctionDeclaration(declaration) || import_ts_morph35.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 isParameterOf(declaration, scanning) {
-  return import_ts_morph35.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
-}
-function parameterIndexOf(declarations, scanning) {
-  if (scanning === void 0) {
-    return void 0;
-  }
-  const params = scanning.getParameters();
-  for (const declaration of declarations) {
-    const index = params.findIndex((param) => param === declaration);
-    if (index !== -1) {
-      return index;
-    }
-  }
-  return void 0;
-}
-function classifyStop(declarations, scanning) {
-  if (declarations.length === 0) {
-    return "noDeclaration";
-  }
-  for (const declaration of declarations) {
-    if (!isInExternalCode(declaration.getSourceFile())) {
-      recordFileDependency(declaration.getSourceFile().getFilePath());
-    }
-  }
-  if (scanning !== void 0 && declarations.some((declaration) => isParameterOf(declaration, scanning))) {
-    return "callerSupplied";
-  }
-  if (declarations.every(isExternalDeclaration)) {
-    return "outsideRun";
-  }
-  if (declarations.some(statesShapeOnly)) {
-    return "noBody";
-  }
-  return "unsettledValue";
-}
-
-// src/discovery/registrationTemplate.ts
 function discoverRegistrationTemplates(sourceFile, match, kind, resolution, mountPrefixes) {
   const results = [];
   for (const node of helperCallsOf(sourceFile, match, resolution)) {
@@ -8494,15 +8612,15 @@ function helperCallsOf(sourceFile, match, resolution) {
     return callsResolvingTo(sourceFile, store, {
       module: module2,
       name: match.helperName
-    }).filter(import_ts_morph36.Node.isCallExpression);
+    }).filter(import_ts_morph37.Node.isCallExpression);
   }
   const calls = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph36.Node.isCallExpression(node)) {
+    if (!import_ts_morph37.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph36.Node.isIdentifier(callee) || callee.getText() !== match.helperName) {
+    if (!import_ts_morph37.Node.isIdentifier(callee) || callee.getText() !== match.helperName) {
       return;
     }
     if (module2 === void 0 || declaredInModule(callee, module2)) {
@@ -8546,7 +8664,7 @@ function substitutePath(template, args) {
   return result;
 }
 function readStringLiteral(node) {
-  if (import_ts_morph36.Node.isStringLiteral(node) || import_ts_morph36.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph37.Node.isStringLiteral(node) || import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
@@ -8569,7 +8687,7 @@ function resolveHandler(template, args, resolution) {
   return readPropertyAsFunction(arg, prop, resolution);
 }
 function handlerName2(value) {
-  return import_ts_morph36.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph37.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 function readPropertyAsFunction(arg, prop, resolution) {
   const obj = objectLiteralOf(arg, resolution);
@@ -8580,7 +8698,7 @@ function readPropertyAsFunction(arg, prop, resolution) {
     if (propertyName(property) !== prop) {
       continue;
     }
-    if (import_ts_morph36.Node.isMethodDeclaration(property)) {
+    if (import_ts_morph37.Node.isMethodDeclaration(property)) {
       return { func: property, name: prop };
     }
     const held = propertyValueOf(property);
@@ -8588,19 +8706,19 @@ function readPropertyAsFunction(arg, prop, resolution) {
       return null;
     }
     const func = functionValueOf(held, resolution);
-    return func === null ? null : { func, name: import_ts_morph36.Node.isIdentifier(held) ? held.getText() : prop };
+    return func === null ? null : { func, name: import_ts_morph37.Node.isIdentifier(held) ? held.getText() : prop };
   }
   return null;
 }
 function propertyName(property) {
-  if (import_ts_morph36.Node.isPropertyAssignment(property) || import_ts_morph36.Node.isShorthandPropertyAssignment(property) || import_ts_morph36.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph37.Node.isPropertyAssignment(property) || import_ts_morph37.Node.isShorthandPropertyAssignment(property) || import_ts_morph37.Node.isMethodDeclaration(property)) {
     return property.getName();
   }
   return null;
 }
 
 // src/discovery/resolverMap.ts
-var import_ts_morph37 = require("ts-morph");
+var import_ts_morph38 = require("ts-morph");
 function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const store = resolution ?? new ResolutionStore();
   const mapProperty = match.mapProperty;
@@ -8611,7 +8729,7 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
     name: match.importName
   })) {
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph37.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph38.Node.isObjectLiteralExpression(args[0])) {
       continue;
     }
     const config = args[0];
@@ -8665,7 +8783,7 @@ function resolverMapObject(prop, resolution) {
   return held === null ? null : objectLiteralOf(held, resolution);
 }
 function extractTypeDefsSdl(config, resolution) {
-  if (!import_ts_morph37.Node.isObjectLiteralExpression(config)) {
+  if (!import_ts_morph38.Node.isObjectLiteralExpression(config)) {
     return null;
   }
   const prop = config.getProperty("typeDefs");
@@ -8687,15 +8805,15 @@ function schemaSdlOf(expr, resolution) {
   return resolved === null ? null : writtenSdl(resolved);
 }
 function writtenSdl(expr) {
-  if (import_ts_morph37.Node.isStringLiteral(expr) || import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph38.Node.isStringLiteral(expr) || import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(expr)) {
     const value = expr.getLiteralValue();
     return value === "" ? null : value;
   }
-  if (import_ts_morph37.Node.isTaggedTemplateExpression(expr)) {
+  if (import_ts_morph38.Node.isTaggedTemplateExpression(expr)) {
     const tag = expr.getTag();
-    if (import_ts_morph37.Node.isIdentifier(tag) && tag.getText() === "gql") {
+    if (import_ts_morph38.Node.isIdentifier(tag) && tag.getText() === "gql") {
       const template = expr.getTemplate();
-      if (import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(template)) {
+      if (import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(template)) {
         return template.getLiteralValue();
       }
     }
@@ -8704,7 +8822,7 @@ function writtenSdl(expr) {
 }
 
 // src/discovery/index.ts
-function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElsewhere) {
+function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElsewhere, routeWrapperPattern) {
   if (pattern.match.type === "namedExport") {
     return discoverNamedExports(
       sourceFile,
@@ -8721,7 +8839,8 @@ function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElse
       pattern.bindingExtraction,
       resolution,
       mountPrefixes,
-      expandedElsewhere
+      expandedElsewhere,
+      routeWrapperPattern
     );
   }
   if (pattern.match.type === "registrationTemplate") {
@@ -8827,19 +8946,26 @@ function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElse
   }
   return [];
 }
+function routeWrapperPatternOf(patterns) {
+  return patterns.find(
+    (pattern) => pattern.wraps !== void 0 && "method" in pattern.wraps && pattern.wraps.continuationParam !== void 0 && pattern.wraps.throwParam === void 0 && pattern.wraps.arity === void 0 && pattern.wraps.scopePosition === void 0
+  );
+}
 function discoverUnits(sourceFile, patterns, resolution, mountPrefixes, expandedElsewhere) {
   const store = resolution ?? new ResolutionStore();
   const allResults = [];
+  const routeWrapperPattern = routeWrapperPatternOf(patterns);
   for (const pattern of patterns) {
     const found = runPattern(
       sourceFile,
       pattern,
       store,
       mountPrefixes,
-      expandedElsewhere
+      expandedElsewhere,
+      routeWrapperPattern
     );
     for (const unit of found) {
-      unit.pattern = pattern;
+      unit.pattern ??= pattern;
     }
     allResults.push(...found);
   }
@@ -8858,7 +8984,7 @@ function discoverUnits(sourceFile, patterns, resolution, mountPrefixes, expanded
 // src/resolve/functionBehind.ts
 function symbolBehind(node) {
   const parent = node.getParent();
-  if (parent !== void 0 && import_ts_morph38.Node.isShorthandPropertyAssignment(parent)) {
+  if (parent !== void 0 && import_ts_morph39.Node.isShorthandPropertyAssignment(parent)) {
     return parent.getValueSymbol();
   }
   return node.getSymbol();
@@ -8888,9 +9014,9 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph38.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph39.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph38.Node.isArrowFunction(init) || import_ts_morph38.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph39.Node.isArrowFunction(init) || import_ts_morph39.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
@@ -8898,20 +9024,20 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph38.Node.isFunctionDeclaration(decl) || import_ts_morph38.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph39.Node.isFunctionDeclaration(decl) || import_ts_morph39.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph38.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph39.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_morph38.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph39.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
@@ -8923,14 +9049,14 @@ function pathAbove(reference) {
   let current2 = reference;
   for (; ; ) {
     const parent = current2.getParent();
-    if (parent !== void 0 && import_ts_morph39.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
+    if (parent !== void 0 && import_ts_morph40.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
       path15.push(parent.getName());
       current2 = parent;
       continue;
     }
-    if (parent !== void 0 && import_ts_morph39.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
+    if (parent !== void 0 && import_ts_morph40.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
       const argument = parent.getArgumentExpression();
-      if (argument !== void 0 && import_ts_morph39.Node.isStringLiteral(argument)) {
+      if (argument !== void 0 && import_ts_morph40.Node.isStringLiteral(argument)) {
         path15.push(argument.getLiteralValue());
         current2 = parent;
         continue;
@@ -8940,11 +9066,11 @@ function pathAbove(reference) {
   }
 }
 function declaresParameterOf(node, func) {
-  if (import_ts_morph39.Node.isParameterDeclaration(node)) {
+  if (import_ts_morph40.Node.isParameterDeclaration(node)) {
     return node.getParent() === func;
   }
-  if (import_ts_morph39.Node.isBindingElement(node)) {
-    const parameter = node.getFirstAncestor(import_ts_morph39.Node.isParameterDeclaration);
+  if (import_ts_morph40.Node.isBindingElement(node)) {
+    const parameter = node.getFirstAncestor(import_ts_morph40.Node.isParameterDeclaration);
     return parameter !== void 0 && parameter.getParent() === func;
   }
   return false;
@@ -8960,7 +9086,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph39.Node.isIdentifier(node) || !wanted.has(node.getText())) {
+    if (!import_ts_morph40.Node.isIdentifier(node) || !wanted.has(node.getText())) {
       return;
     }
     const declarations = symbolBehind(node)?.getDeclarations() ?? [];
@@ -8983,7 +9109,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
 }
 
 // src/resolve/readName.ts
-var import_ts_morph40 = require("ts-morph");
+var import_ts_morph41 = require("ts-morph");
 var import_behavioral_ir3 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
@@ -9018,11 +9144,11 @@ function referenceIn(expr) {
 function parameterPath(expr) {
   const fields = [];
   let step = expr;
-  while (import_ts_morph40.Node.isPropertyAccessExpression(step)) {
+  while (import_ts_morph41.Node.isPropertyAccessExpression(step)) {
     fields.unshift(step.getName());
     step = step.getExpression();
   }
-  if (!import_ts_morph40.Node.isIdentifier(step) || !isParameter(step)) {
+  if (!import_ts_morph41.Node.isIdentifier(step) || !isParameter(step)) {
     return null;
   }
   return { root: step.getText(), fields };
@@ -9030,7 +9156,7 @@ function parameterPath(expr) {
 function isParameter(identifier) {
   const declarations = identifier.getSymbol()?.getDeclarations() ?? [];
   return declarations.some(
-    (declaration) => import_ts_morph40.Node.isParameterDeclaration(declaration)
+    (declaration) => import_ts_morph41.Node.isParameterDeclaration(declaration)
   );
 }
 function read(expr, ctx) {
@@ -9039,25 +9165,25 @@ function read(expr, ctx) {
   }
   const seen = new Set(ctx.seen).add(expr);
   const inner = { ...ctx, seen };
-  if (import_ts_morph40.Node.isStringLiteral(expr) || import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph41.Node.isStringLiteral(expr) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.getLiteralValue();
   }
-  if (import_ts_morph40.Node.isNumericLiteral(expr)) {
+  if (import_ts_morph41.Node.isNumericLiteral(expr)) {
     return expr.getLiteralText();
   }
-  if (import_ts_morph40.Node.isTemplateExpression(expr)) {
+  if (import_ts_morph41.Node.isTemplateExpression(expr)) {
     return fromTemplate(expr, inner);
   }
-  if (import_ts_morph40.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph41.Node.isParenthesizedExpression(expr)) {
     return read(peelParens(expr), inner);
   }
-  if (import_ts_morph40.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph41.Node.isBinaryExpression(expr)) {
     return fromBinary(expr, inner);
   }
-  if (import_ts_morph40.Node.isCallExpression(expr)) {
+  if (import_ts_morph41.Node.isCallExpression(expr)) {
     return fromCall(expr, inner);
   }
-  if (import_ts_morph40.Node.isIdentifier(expr)) {
+  if (import_ts_morph41.Node.isIdentifier(expr)) {
     const only = boundOnce(expr, ctx);
     if (only !== null) {
       return read(only.node, { ...inner, bindings: only.scope });
@@ -9077,17 +9203,17 @@ function read(expr, ctx) {
 }
 function isFallbackBranch(node) {
   let step = node.getParent();
-  while (step !== void 0 && import_ts_morph40.Node.isParenthesizedExpression(step)) {
+  while (step !== void 0 && import_ts_morph41.Node.isParenthesizedExpression(step)) {
     step = step.getParent();
   }
-  if (step === void 0 || !import_ts_morph40.Node.isBinaryExpression(step)) {
+  if (step === void 0 || !import_ts_morph41.Node.isBinaryExpression(step)) {
     return false;
   }
   const operator = step.getOperatorToken().getKind();
-  return operator === import_ts_morph40.SyntaxKind.BarBarToken || operator === import_ts_morph40.SyntaxKind.QuestionQuestionToken;
+  return operator === import_ts_morph41.SyntaxKind.BarBarToken || operator === import_ts_morph41.SyntaxKind.QuestionQuestionToken;
 }
 function fromTemplate(expr, ctx) {
-  if (!import_ts_morph40.Node.isTemplateExpression(expr)) {
+  if (!import_ts_morph41.Node.isTemplateExpression(expr)) {
     return null;
   }
   let name = expr.getHead().getLiteralText();
@@ -9098,28 +9224,28 @@ function fromTemplate(expr, ctx) {
   return name;
 }
 function fromBinary(expr, ctx) {
-  if (!import_ts_morph40.Node.isBinaryExpression(expr)) {
+  if (!import_ts_morph41.Node.isBinaryExpression(expr)) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === import_ts_morph40.SyntaxKind.BarBarToken || operator === import_ts_morph40.SyntaxKind.QuestionQuestionToken) {
+  if (operator === import_ts_morph41.SyntaxKind.BarBarToken || operator === import_ts_morph41.SyntaxKind.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== import_ts_morph40.SyntaxKind.PlusToken) {
+  if (operator !== import_ts_morph41.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_morph40.Node.isCallExpression(expr)) {
+  if (!import_ts_morph41.Node.isCallExpression(expr)) {
     return null;
   }
   const callee = expr.getExpression();
-  if (import_ts_morph40.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
+  if (import_ts_morph41.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
     return fromJoin(callee.getExpression(), expr.getArguments(), ctx);
   }
-  if (import_ts_morph40.Node.isIdentifier(callee) && callee.getText() === "String") {
+  if (import_ts_morph41.Node.isIdentifier(callee) && callee.getText() === "String") {
     const only = expr.getArguments()[0];
     return only === void 0 ? null : readOrHole(only, ctx);
   }
@@ -9138,7 +9264,7 @@ function fromCall(expr, ctx) {
 }
 function fromJoin(subject, args, ctx) {
   const separator = args[0];
-  if (separator === void 0 || !import_ts_morph40.Node.isStringLiteral(separator)) {
+  if (separator === void 0 || !import_ts_morph41.Node.isStringLiteral(separator)) {
     return null;
   }
   const parts = elementsOf(subject, ctx);
@@ -9154,17 +9280,17 @@ function fromJoin(subject, args, ctx) {
   ).join(separator.getLiteralValue());
 }
 function elementsOf(subject, ctx) {
-  if (import_ts_morph40.Node.isArrayLiteralExpression(subject)) {
+  if (import_ts_morph41.Node.isArrayLiteralExpression(subject)) {
     return subject.getElements().map((element) => here(element, ctx));
   }
-  if (import_ts_morph40.Node.isCallExpression(subject)) {
+  if (import_ts_morph41.Node.isCallExpression(subject)) {
     const callee = subject.getExpression();
-    if (import_ts_morph40.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
+    if (import_ts_morph41.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
       return elementsOf(callee.getExpression(), ctx);
     }
     return null;
   }
-  if (!import_ts_morph40.Node.isIdentifier(subject)) {
+  if (!import_ts_morph41.Node.isIdentifier(subject)) {
     return null;
   }
   const bound = ctx.bindings.get(subject.getText());
@@ -9172,7 +9298,7 @@ function elementsOf(subject, ctx) {
     return null;
   }
   const only = bound.length === 1 ? bound[0] : void 0;
-  return only !== void 0 && import_ts_morph40.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
+  return only !== void 0 && import_ts_morph41.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
 }
 function singleReturnBody(callee, ctx) {
   const declaration = declarationOf2(callee, ctx);
@@ -9187,22 +9313,22 @@ function singleReturnBody(callee, ctx) {
   if (body === void 0) {
     return null;
   }
-  if (import_ts_morph40.Node.isExpression(body)) {
+  if (import_ts_morph41.Node.isExpression(body)) {
     return { parameters, returned: body };
   }
-  if (!import_ts_morph40.Node.isBlock(body)) {
+  if (!import_ts_morph41.Node.isBlock(body)) {
     return null;
   }
   const statements = body.getStatements();
   const only = statements[0];
-  if (statements.length !== 1 || only === void 0 || !import_ts_morph40.Node.isReturnStatement(only)) {
+  if (statements.length !== 1 || only === void 0 || !import_ts_morph41.Node.isReturnStatement(only)) {
     return null;
   }
   const returned = only.getExpression();
   return returned === void 0 ? null : { parameters, returned };
 }
 function declarationOf2(callee, ctx) {
-  const symbol = import_ts_morph40.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
+  const symbol = import_ts_morph41.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
   const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
   for (const declaration of declarations) {
     const callable = asCallable(declaration);
@@ -9214,14 +9340,14 @@ function declarationOf2(callee, ctx) {
   return written === null || written === callee ? null : declarationOf2(written, { ...ctx, resolve: () => null });
 }
 function asCallable(declaration) {
-  if (import_ts_morph40.Node.isFunctionDeclaration(declaration) || import_ts_morph40.Node.isMethodDeclaration(declaration) || import_ts_morph40.Node.isArrowFunction(declaration) || import_ts_morph40.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph41.Node.isFunctionDeclaration(declaration) || import_ts_morph41.Node.isMethodDeclaration(declaration) || import_ts_morph41.Node.isArrowFunction(declaration) || import_ts_morph41.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (!import_ts_morph40.Node.isVariableDeclaration(declaration)) {
+  if (!import_ts_morph41.Node.isVariableDeclaration(declaration)) {
     return null;
   }
   const initializer = declaration.getInitializer();
-  if (initializer !== void 0 && (import_ts_morph40.Node.isArrowFunction(initializer) || import_ts_morph40.Node.isFunctionExpression(initializer))) {
+  if (initializer !== void 0 && (import_ts_morph41.Node.isArrowFunction(initializer) || import_ts_morph41.Node.isFunctionExpression(initializer))) {
     return initializer;
   }
   return null;
@@ -9243,7 +9369,7 @@ function here(node, ctx) {
   return { node, scope: ctx.bindings };
 }
 function boundOnce(expr, ctx) {
-  const bound = import_ts_morph40.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
+  const bound = import_ts_morph41.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
   return bound !== void 0 && bound.length === 1 ? bound[0] : null;
 }
 function readOrHole(expr, ctx) {
@@ -9255,10 +9381,10 @@ function holeName(expr, ctx) {
   if (bound !== null) {
     return holeName(bound.node, { ...ctx, bindings: bound.scope });
   }
-  if (import_ts_morph40.Node.isIdentifier(expr)) {
+  if (import_ts_morph41.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph40.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph41.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return UNNAMED_HOLE;
@@ -9285,8 +9411,8 @@ function madeFromNamed(origin, made) {
   return origin.named.includes(constructorName(made));
 }
 function constructorName(made) {
-  const expression = import_ts_morph41.Node.isNewExpression(made) || import_ts_morph41.Node.isCallExpression(made) ? made.getExpression() : made;
-  return import_ts_morph41.Node.isPropertyAccessExpression(expression) ? expression.getName() : expression.getText();
+  const expression = import_ts_morph42.Node.isNewExpression(made) || import_ts_morph42.Node.isCallExpression(made) ? made.getExpression() : made;
+  return import_ts_morph42.Node.isPropertyAccessExpression(expression) ? expression.getName() : expression.getText();
 }
 var CALL_ORIGIN = {
   declaredBy: ORIGIN.declaredBy,
@@ -9300,7 +9426,7 @@ var CALL_ORIGIN = {
 };
 function madeBy(receiver) {
   const made = madeExpression(receiver);
-  const expression = import_ts_morph41.Node.isNewExpression(made) || import_ts_morph41.Node.isCallExpression(made) ? made.getExpression() : made;
+  const expression = import_ts_morph42.Node.isNewExpression(made) || import_ts_morph42.Node.isCallExpression(made) ? made.getExpression() : made;
   return rootIdentifier(expression) ?? expression;
 }
 function madeExpression(receiver) {
@@ -9308,7 +9434,7 @@ function madeExpression(receiver) {
     return receiver.expression;
   }
   const written = receiver.resolve(receiver.callee.getExpression());
-  if (written === null || !import_ts_morph41.Node.isNewExpression(written) && !import_ts_morph41.Node.isCallExpression(written)) {
+  if (written === null || !import_ts_morph42.Node.isNewExpression(written) && !import_ts_morph42.Node.isCallExpression(written)) {
     return receiver.callee;
   }
   return written;
@@ -9316,7 +9442,7 @@ function madeExpression(receiver) {
 function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   const resolve2 = resolveWrittenValue ?? (() => null);
   const expression = calleeOf3(call);
-  const callee = import_ts_morph41.Node.isPropertyAccessExpression(expression) ? expression : null;
+  const callee = import_ts_morph42.Node.isPropertyAccessExpression(expression) ? expression : null;
   let args = null;
   const argumentsOf = () => {
     args ??= argumentsIn(call);
@@ -9339,7 +9465,7 @@ function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
     argumentCount: () => argumentsOf().length,
     nameAt: (index, unsettled) => nameAt(argumentsOf()[index], unsettled, resolve2),
     calleeText: () => expression.getText(),
-    namedCallee: () => import_ts_morph41.Node.isIdentifier(expression),
+    namedCallee: () => import_ts_morph42.Node.isIdentifier(expression),
     parameterReadsAt: (index) => selectorReadsOf(argumentsOf()[index]),
     receiver: () => callee === null ? null : opsOverCall(callee.getExpression(), resolve2),
     argument: (index) => opsOverCall(argumentsOf()[index], resolve2),
@@ -9364,7 +9490,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
     return null;
   }
   const found = anchorCallsOf(subject, (candidate) => {
-    if (!import_ts_morph41.Node.isCallExpression(candidate) && !import_ts_morph41.Node.isNewExpression(candidate)) {
+    if (!import_ts_morph42.Node.isCallExpression(candidate) && !import_ts_morph42.Node.isNewExpression(candidate)) {
       return false;
     }
     const candidateCallee = calleeOf3(candidate);
@@ -9379,7 +9505,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
   if (distinct.length !== 1 || only === void 0) {
     return null;
   }
-  if (!import_ts_morph41.Node.isCallExpression(only) && !import_ts_morph41.Node.isNewExpression(only)) {
+  if (!import_ts_morph42.Node.isCallExpression(only) && !import_ts_morph42.Node.isNewExpression(only)) {
     return null;
   }
   return callOpsFor(only, resolve2, originatesFrom, anchorCallsOf);
@@ -9399,7 +9525,7 @@ function valueOpsFor(value, resolve2) {
     asArg: () => effectArgOf(written()),
     property: (name) => {
       const object = written();
-      const inside = import_ts_morph41.Node.isObjectLiteralExpression(object) ? initializerOf(object, name) : null;
+      const inside = import_ts_morph42.Node.isObjectLiteralExpression(object) ? initializerOf(object, name) : null;
       return inside === null ? null : valueOpsFor(inside, resolve2);
     },
     parts: () => literalParts(written()),
@@ -9412,7 +9538,7 @@ function literalParts(value) {
   if (whole !== null) {
     return [whole];
   }
-  if (!import_ts_morph41.Node.isTemplateExpression(written)) {
+  if (!import_ts_morph42.Node.isTemplateExpression(written)) {
     return null;
   }
   return [
@@ -9422,26 +9548,26 @@ function literalParts(value) {
 }
 function templateHoles(value, resolve2) {
   const written = untagged(value);
-  if (!import_ts_morph41.Node.isTemplateExpression(written)) {
+  if (!import_ts_morph42.Node.isTemplateExpression(written)) {
     return [];
   }
   return written.getTemplateSpans().map((span) => opsOverCall(span.getExpression(), resolve2));
 }
 function untagged(value) {
-  return import_ts_morph41.Node.isTaggedTemplateExpression(value) ? value.getTemplate() : value;
+  return import_ts_morph42.Node.isTaggedTemplateExpression(value) ? value.getTemplate() : value;
 }
 function entriesOf(value, unsettled, resolve2) {
-  if (!import_ts_morph41.Node.isObjectLiteralExpression(value)) {
+  if (!import_ts_morph42.Node.isObjectLiteralExpression(value)) {
     return [];
   }
   const found = [];
   for (const written of value.getProperties()) {
-    if (import_ts_morph41.Node.isShorthandPropertyAssignment(written)) {
+    if (import_ts_morph42.Node.isShorthandPropertyAssignment(written)) {
       const name = written.getNameNode();
       found.push({ key: name.getText(), value: valueOpsFor(name, resolve2) });
       continue;
     }
-    if (!import_ts_morph41.Node.isPropertyAssignment(written)) {
+    if (!import_ts_morph42.Node.isPropertyAssignment(written)) {
       continue;
     }
     const stated = written.getInitializer();
@@ -9454,35 +9580,35 @@ function entriesOf(value, unsettled, resolve2) {
 }
 function entryKey(written, unsettled, resolve2) {
   const name = written.getNameNode();
-  if (import_ts_morph41.Node.isComputedPropertyName(name)) {
+  if (import_ts_morph42.Node.isComputedPropertyName(name)) {
     return readName(name.getExpression(), { resolve: resolve2, unsettled });
   }
   return unquoted(written.getName());
 }
 function itemsOf(value, resolve2) {
-  if (!import_ts_morph41.Node.isArrayLiteralExpression(value)) {
+  if (!import_ts_morph42.Node.isArrayLiteralExpression(value)) {
     return [];
   }
   return value.getElements().map((element) => valueOpsFor(element, resolve2));
 }
 function literalText(value) {
-  return import_ts_morph41.Node.isStringLiteral(value) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
+  return import_ts_morph42.Node.isStringLiteral(value) || import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
 }
 function literalFlag(value) {
-  if (import_ts_morph41.Node.isTrueLiteral(value) || import_ts_morph41.Node.isFalseLiteral(value)) {
-    return import_ts_morph41.Node.isTrueLiteral(value);
+  if (import_ts_morph42.Node.isTrueLiteral(value) || import_ts_morph42.Node.isFalseLiteral(value)) {
+    return import_ts_morph42.Node.isTrueLiteral(value);
   }
-  return import_ts_morph41.Node.isNumericLiteral(value) ? value.getLiteralValue() !== 0 : null;
+  return import_ts_morph42.Node.isNumericLiteral(value) ? value.getLiteralValue() !== 0 : null;
 }
 function unquoted(name) {
   return name.replace(/^["']|["']$/g, "");
 }
 function selectorReadsOf(argument) {
-  if (argument === void 0 || !import_ts_morph41.Node.isArrowFunction(argument) && !import_ts_morph41.Node.isFunctionExpression(argument)) {
+  if (argument === void 0 || !import_ts_morph42.Node.isArrowFunction(argument) && !import_ts_morph42.Node.isFunctionExpression(argument)) {
     return null;
   }
   const parameter = argument.getParameters()[0];
-  if (parameter === void 0 || !import_ts_morph41.Node.isIdentifier(parameter.getNameNode())) {
+  if (parameter === void 0 || !import_ts_morph42.Node.isIdentifier(parameter.getNameNode())) {
     return null;
   }
   const names = /* @__PURE__ */ new Set();
@@ -9499,17 +9625,17 @@ function opsOverCall(value, resolve2) {
   return callOpsFor(written, resolve2);
 }
 function isCalled(value) {
-  return import_ts_morph41.Node.isCallExpression(value) || import_ts_morph41.Node.isNewExpression(value) || import_ts_morph41.Node.isTaggedTemplateExpression(value);
+  return import_ts_morph42.Node.isCallExpression(value) || import_ts_morph42.Node.isNewExpression(value) || import_ts_morph42.Node.isTaggedTemplateExpression(value);
 }
 function calleeOf3(call) {
-  return import_ts_morph41.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
+  return import_ts_morph42.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
 }
 function argumentsIn(call) {
-  return import_ts_morph41.Node.isTaggedTemplateExpression(call) ? [call.getTemplate()] : call.getArguments();
+  return import_ts_morph42.Node.isTaggedTemplateExpression(call) ? [call.getTemplate()] : call.getArguments();
 }
 function settled(value, resolve2) {
   const step = unwrapped(value ?? null);
-  if (step === null || !import_ts_morph41.Node.isIdentifier(step)) {
+  if (step === null || !import_ts_morph42.Node.isIdentifier(step)) {
     return step;
   }
   return unwrapped(resolve2(step));
@@ -9536,11 +9662,11 @@ function objectAt(argument, resolve2) {
   if (isCalled(written)) {
     return objectAt(argumentsIn(written)[0], resolve2);
   }
-  return import_ts_morph41.Node.isObjectLiteralExpression(written) ? written : null;
+  return import_ts_morph42.Node.isObjectLiteralExpression(written) ? written : null;
 }
 function initializerOf(object, property) {
   for (const written of object.getProperties()) {
-    if (import_ts_morph41.Node.isPropertyAssignment(written) && written.getName() === property) {
+    if (import_ts_morph42.Node.isPropertyAssignment(written) && written.getName() === property) {
       return written.getInitializer() ?? null;
     }
   }
@@ -9570,7 +9696,7 @@ function invocationContextFor(call, resolveWrittenValue, originatesFrom, anchorC
   };
 }
 function isImportedFrom(identifier, expectedModule, originatesFrom) {
-  if (!import_ts_morph42.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph43.Node.isIdentifier(identifier)) {
     return false;
   }
   const symbol = identifier.getSymbol();
@@ -9591,7 +9717,7 @@ function isImportedFrom(identifier, expectedModule, originatesFrom) {
   );
 }
 function methodDeclaredIn(callee, expectedModule, resolve2, originatesFrom) {
-  if (!import_ts_morph42.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph43.Node.isPropertyAccessExpression(callee)) {
     return false;
   }
   const declarations = callee.getNameNode().getSymbol()?.getDeclarations();
@@ -9611,37 +9737,37 @@ function maker(written) {
   if (written === null) {
     return null;
   }
-  if (import_ts_morph42.Node.isNewExpression(written) || import_ts_morph42.Node.isCallExpression(written)) {
+  if (import_ts_morph43.Node.isNewExpression(written) || import_ts_morph43.Node.isCallExpression(written)) {
     return written.getExpression();
   }
   return null;
 }
 function rootIdentifier2(expression) {
   let root = expression;
-  while (import_ts_morph42.Node.isPropertyAccessExpression(root)) {
+  while (import_ts_morph43.Node.isPropertyAccessExpression(root)) {
     root = root.getExpression();
   }
   return root;
 }
 function importSpecifierMatches(decl, expectedModule) {
-  if (import_ts_morph42.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph43.Node.isImportSpecifier(decl)) {
     return decl.getImportDeclaration().getModuleSpecifierValue() === expectedModule;
   }
-  const owner = import_ts_morph42.Node.isNamespaceImport(decl) ? decl.getParent() : decl;
-  if (!import_ts_morph42.Node.isImportClause(owner)) {
+  const owner = import_ts_morph43.Node.isNamespaceImport(decl) ? decl.getParent() : decl;
+  if (!import_ts_morph43.Node.isImportClause(owner)) {
     return false;
   }
   const importDecl = owner.getParent();
-  return import_ts_morph42.Node.isImportDeclaration(importDecl) && importDecl.getModuleSpecifierValue() === expectedModule;
+  return import_ts_morph43.Node.isImportDeclaration(importDecl) && importDecl.getModuleSpecifierValue() === expectedModule;
 }
 function extractInvocationEffects(func, barriers = NO_BARRIERS) {
   const calls = [];
   func.forEachDescendant((node, traversal) => {
-    if (isDescentStop(node, func, barriers) || import_ts_morph42.Node.isDecorator(node)) {
+    if (isDescentStop(node, func, barriers) || import_ts_morph43.Node.isDecorator(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph42.Node.isCallExpression(node)) {
+    if (import_ts_morph43.Node.isCallExpression(node)) {
       calls.push(node);
     }
   });
@@ -9665,10 +9791,10 @@ function invocationAt(call, func) {
 }
 function isAwaited(call) {
   let current2 = call.getParent();
-  while (current2 !== void 0 && import_ts_morph42.Node.isParenthesizedExpression(current2)) {
+  while (current2 !== void 0 && import_ts_morph43.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getParent();
   }
-  return current2 !== void 0 && import_ts_morph42.Node.isAwaitExpression(current2);
+  return current2 !== void 0 && import_ts_morph43.Node.isAwaitExpression(current2);
 }
 function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   if (recognizers.length === 0) {
@@ -9681,7 +9807,7 @@ function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, res
       traversal.skip();
       return;
     }
-    if (!import_ts_morph42.Node.isCallExpression(node)) {
+    if (!import_ts_morph43.Node.isCallExpression(node)) {
       return;
     }
     const ctx = invocationContextFor(
@@ -9743,7 +9869,7 @@ function runAccessRecognizersAtModuleScope(sourceFile, recognizers, resolveWritt
 }
 function accessContextFor(node, sourceFile, resolveWrittenValue = () => null, originatesFrom, anchorCallsOf) {
   const given = { access: node, sourceFile, resolveWrittenValue };
-  if (import_ts_morph42.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph43.Node.isPropertyAccessExpression(node)) {
     return given;
   }
   let ops;
@@ -9772,7 +9898,7 @@ function dispatchAccessRecognizers(root, recognizers, isStop, resolveWrittenValu
       traversal.skip();
       return;
     }
-    if (!import_ts_morph42.Node.isPropertyAccessExpression(node) && !import_ts_morph42.Node.isCallExpression(node) && !import_ts_morph42.Node.isTaggedTemplateExpression(node)) {
+    if (!import_ts_morph43.Node.isPropertyAccessExpression(node) && !import_ts_morph43.Node.isCallExpression(node) && !import_ts_morph43.Node.isTaggedTemplateExpression(node)) {
       return;
     }
     const ctx = accessContextFor(
@@ -9828,35 +9954,35 @@ function extractArg(node, depth) {
       return extractArg(bare, depth);
     }
   }
-  if (import_ts_morph42.Node.isStringLiteral(node) || import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph43.Node.isStringLiteral(node) || import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { kind: "string", value: node.getLiteralValue() };
   }
-  if (import_ts_morph42.Node.isNumericLiteral(node)) {
+  if (import_ts_morph43.Node.isNumericLiteral(node)) {
     return { kind: "number", value: node.getLiteralValue() };
   }
-  if (import_ts_morph42.Node.isTrueLiteral(node)) {
+  if (import_ts_morph43.Node.isTrueLiteral(node)) {
     return { kind: "boolean", value: true };
   }
-  if (import_ts_morph42.Node.isFalseLiteral(node)) {
+  if (import_ts_morph43.Node.isFalseLiteral(node)) {
     return { kind: "boolean", value: false };
   }
-  if (import_ts_morph42.Node.isTemplateExpression(node)) {
+  if (import_ts_morph43.Node.isTemplateExpression(node)) {
     return { kind: "template", sourceText: node.getText() };
   }
-  if (import_ts_morph42.Node.isIdentifier(node)) {
+  if (import_ts_morph43.Node.isIdentifier(node)) {
     const inlined = inlineModuleBinding(node, depth);
     if (inlined !== null) {
       return inlined;
     }
     return { kind: "identifier", name: node.getText() };
   }
-  if (import_ts_morph42.Node.isPropertyAccessExpression(node) || import_ts_morph42.Node.isElementAccessExpression(node)) {
+  if (import_ts_morph43.Node.isPropertyAccessExpression(node) || import_ts_morph43.Node.isElementAccessExpression(node)) {
     return { kind: "identifier", name: node.getText() };
   }
   if (depth <= 0) {
     return null;
   }
-  if (import_ts_morph42.Node.isCallExpression(node)) {
+  if (import_ts_morph43.Node.isCallExpression(node)) {
     const element = mapCallbackReturn(node);
     if (element !== null) {
       return { kind: "array", items: [extractArg(element, depth - 1)] };
@@ -9867,19 +9993,19 @@ function extractArg(node, depth) {
       args: node.getArguments().map((a) => extractArg(a, depth - 1))
     };
   }
-  if (import_ts_morph42.Node.isNewExpression(node)) {
+  if (import_ts_morph43.Node.isNewExpression(node)) {
     return {
       kind: "call",
       callee: node.getExpression().getText(),
       args: node.getArguments().map((a) => extractArg(a, depth - 1))
     };
   }
-  if (import_ts_morph42.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph43.Node.isObjectLiteralExpression(node)) {
     const fields = {};
     for (const prop of node.getProperties()) {
-      if (import_ts_morph42.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph43.Node.isShorthandPropertyAssignment(prop)) {
         const nameNode2 = prop.getNameNode();
-        if (import_ts_morph42.Node.isIdentifier(nameNode2)) {
+        if (import_ts_morph43.Node.isIdentifier(nameNode2)) {
           fields[nameNode2.getText()] = {
             kind: "identifier",
             name: nameNode2.getText()
@@ -9887,14 +10013,14 @@ function extractArg(node, depth) {
         }
         continue;
       }
-      if (!import_ts_morph42.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph43.Node.isPropertyAssignment(prop)) {
         continue;
       }
       const nameNode = prop.getNameNode();
-      if (!import_ts_morph42.Node.isIdentifier(nameNode) && !import_ts_morph42.Node.isStringLiteral(nameNode) && !import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
+      if (!import_ts_morph43.Node.isIdentifier(nameNode) && !import_ts_morph43.Node.isStringLiteral(nameNode) && !import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
         continue;
       }
-      const name = import_ts_morph42.Node.isIdentifier(nameNode) ? nameNode.getText() : nameNode.getLiteralValue();
+      const name = import_ts_morph43.Node.isIdentifier(nameNode) ? nameNode.getText() : nameNode.getLiteralValue();
       const initializer = prop.getInitializer();
       if (initializer === void 0) {
         continue;
@@ -9903,7 +10029,7 @@ function extractArg(node, depth) {
     }
     return { kind: "object", fields };
   }
-  if (import_ts_morph42.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph43.Node.isArrayLiteralExpression(node)) {
     const items = node.getElements().map((el) => extractArg(el, depth - 1));
     return { kind: "array", items };
   }
@@ -9911,20 +10037,20 @@ function extractArg(node, depth) {
 }
 function mapCallbackReturn(call) {
   const callee = call.getExpression();
-  if (!import_ts_morph42.Node.isPropertyAccessExpression(callee) || callee.getName() !== "map") {
+  if (!import_ts_morph43.Node.isPropertyAccessExpression(callee) || callee.getName() !== "map") {
     return null;
   }
   const callback = call.getArguments()[0];
-  if (callback === void 0 || !(import_ts_morph42.Node.isArrowFunction(callback) || import_ts_morph42.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph43.Node.isArrowFunction(callback) || import_ts_morph43.Node.isFunctionExpression(callback))) {
     return null;
   }
   const body = callback.getBody();
-  if (!import_ts_morph42.Node.isBlock(body)) {
+  if (!import_ts_morph43.Node.isBlock(body)) {
     return body;
   }
   const statements = body.getStatements();
   const only = statements.length === 1 ? statements[0] : void 0;
-  return only !== void 0 && import_ts_morph42.Node.isReturnStatement(only) ? only.getExpression() ?? null : null;
+  return only !== void 0 && import_ts_morph43.Node.isReturnStatement(only) ? only.getExpression() ?? null : null;
 }
 function collectPreconditions(node, root) {
   return collectAncestorConditionInfosBelow(node, root).map(
@@ -9935,7 +10061,7 @@ function runsOnEveryPath(node, root) {
   let current2 = node;
   while (current2 !== void 0 && current2 !== root) {
     const parent = current2.getParent();
-    if (parent !== void 0 && import_ts_morph42.Node.isTryStatement(parent) && parent.getFinallyBlock() === current2) {
+    if (parent !== void 0 && import_ts_morph43.Node.isTryStatement(parent) && parent.getFinallyBlock() === current2) {
       return true;
     }
     current2 = parent;
@@ -9958,7 +10084,7 @@ function withPreconditions(effect, preconditions) {
   };
 }
 function inlineModuleBinding(ident, depth) {
-  if (!import_ts_morph42.Node.isIdentifier(ident)) {
+  if (!import_ts_morph43.Node.isIdentifier(ident)) {
     return null;
   }
   const symbol = ident.getSymbol();
@@ -9966,7 +10092,7 @@ function inlineModuleBinding(ident, depth) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (!import_ts_morph42.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph43.Node.isVariableDeclaration(decl)) {
       continue;
     }
     if (!isModuleScoped(decl)) {
@@ -9987,10 +10113,10 @@ function inlineModuleBinding(ident, depth) {
 function isModuleScoped(decl) {
   let current2 = decl.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph42.Node.isSourceFile(current2)) {
+    if (import_ts_morph43.Node.isSourceFile(current2)) {
       return true;
     }
-    if (import_ts_morph42.Node.isVariableDeclarationList(current2) || import_ts_morph42.Node.isVariableStatement(current2)) {
+    if (import_ts_morph43.Node.isVariableDeclarationList(current2) || import_ts_morph43.Node.isVariableStatement(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -10004,7 +10130,7 @@ function unwrapCasts(node) {
 function enclosingStatementLine(node) {
   let current2 = node;
   while (current2 !== void 0) {
-    if (import_ts_morph42.Node.isStatement(current2)) {
+    if (import_ts_morph43.Node.isStatement(current2)) {
       return startLineOf(current2);
     }
     current2 = current2.getParent();
@@ -10013,19 +10139,19 @@ function enclosingStatementLine(node) {
 }
 
 // src/terminals/index.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 
 // src/terminals/continuation.ts
-var import_ts_morph44 = require("ts-morph");
+var import_ts_morph45 = require("ts-morph");
 
 // src/terminals/shared.ts
-var import_ts_morph43 = require("ts-morph");
+var import_ts_morph44 = require("ts-morph");
 function parameterPositionOf(identifier, func) {
-  if (!import_ts_morph43.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph44.Node.isIdentifier(identifier)) {
     return null;
   }
   const declaration = identifier.getSymbol()?.getDeclarations()[0];
-  if (declaration === void 0 || !import_ts_morph43.Node.isParameterDeclaration(declaration)) {
+  if (declaration === void 0 || !import_ts_morph44.Node.isParameterDeclaration(declaration)) {
     return null;
   }
   const params = func.getParameters();
@@ -10042,17 +10168,17 @@ function returnPositionOf(value) {
     if (parent === void 0) {
       return null;
     }
-    if (import_ts_morph43.Node.isReturnStatement(parent)) {
+    if (import_ts_morph44.Node.isReturnStatement(parent)) {
       return parent;
     }
-    if (import_ts_morph43.Node.isArrowFunction(parent)) {
+    if (import_ts_morph44.Node.isArrowFunction(parent)) {
       return parent.getBody() === current2 ? current2 : null;
     }
     if (passesValueThrough(parent)) {
       current2 = parent;
       continue;
     }
-    if (import_ts_morph43.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
+    if (import_ts_morph44.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
       current2 = parent;
       continue;
     }
@@ -10062,7 +10188,7 @@ function returnPositionOf(value) {
 
 // src/terminals/continuation.ts
 function tryMatchParameterCall(node, func, pattern, match) {
-  if (!import_ts_morph44.Node.isCallExpression(node)) {
+  if (!import_ts_morph45.Node.isCallExpression(node)) {
     return null;
   }
   const callee = node.getExpression();
@@ -10085,15 +10211,15 @@ function tryMatchParameterCall(node, func, pattern, match) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph48 = require("ts-morph");
 var import_values5 = require("@suss/values");
 
 // src/shapes/shapes.ts
-var import_ts_morph46 = require("ts-morph");
+var import_ts_morph47 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
-var import_ts_morph45 = require("ts-morph");
+var import_ts_morph46 = require("ts-morph");
 
 // src/shapes/definitions.ts
 var current = null;
@@ -10444,7 +10570,7 @@ function refFromType(type, ctx) {
   }
   return { type: "ref", name: withoutImportQualifiers(type.getText()) };
 }
-var PRINTED_NAME_FLAGS = import_ts_morph45.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | import_ts_morph45.TypeFormatFlags.UseTypeOfFunction | import_ts_morph45.TypeFormatFlags.NoTruncation | import_ts_morph45.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+var PRINTED_NAME_FLAGS = import_ts_morph46.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | import_ts_morph46.TypeFormatFlags.UseTypeOfFunction | import_ts_morph46.TypeFormatFlags.NoTruncation | import_ts_morph46.TypeFormatFlags.WriteTypeArgumentsOfSignature;
 function printedTypeName(type, ctx) {
   return withoutImportQualifiers(
     type.getText(ctx.enclosing, PRINTED_NAME_FLAGS)
@@ -10554,60 +10680,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph46.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph47.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph46.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph46.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph46.Node.isStringLiteral(unwrapped2) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isStringLiteral(unwrapped2) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph46.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph46.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph46.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph46.SyntaxKind.MinusToken || op === import_ts_morph46.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph47.SyntaxKind.MinusToken || op === import_ts_morph47.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph46.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph47.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph46.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph47.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph46.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph47.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph46.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph46.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph46.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph46.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph46.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph47.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph46.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -10638,7 +10764,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph46.Node.isSpreadElement(el)) {
+    if (import_ts_morph47.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -10657,7 +10783,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph46.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph47.Node.isPropertyAssignment(prop)) {
       const name = propertyName2(prop);
       if (name === null) {
         continue;
@@ -10673,7 +10799,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph46.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -10682,7 +10808,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph46.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph47.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -10701,7 +10827,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName2(prop) {
   const nameNode = prop.getNameNode();
-  if (import_ts_morph46.Node.isIdentifier(nameNode) || import_ts_morph46.Node.isStringLiteral(nameNode) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph46.Node.isNumericLiteral(nameNode)) {
+  if (import_ts_morph47.Node.isIdentifier(nameNode) || import_ts_morph47.Node.isStringLiteral(nameNode) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph47.Node.isNumericLiteral(nameNode)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -10732,15 +10858,15 @@ function unwrapAs(node) {
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph47.Node.isCallExpression(outer)) {
+  if (!import_ts_morph48.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph47.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph47.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph48.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -10750,7 +10876,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph47.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph48.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -10794,10 +10920,10 @@ function statusFromProperty(obj, name, ctx) {
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -10820,7 +10946,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph47.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph48.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -10833,7 +10959,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph47.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph48.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -10842,7 +10968,7 @@ function extractStatusCodeFromRule(ctx) {
   if (sc.from === "argumentProperty") {
     const args = ctx.throwCallArgs ?? ctx.calls?.[0]?.getArguments();
     const arg = args?.[sc.position];
-    if (arg === void 0 || !import_ts_morph47.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph48.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -10852,8 +10978,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -10911,8 +11037,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -10967,16 +11093,16 @@ function extractBody(ctx) {
 }
 
 // src/terminals/jsx.ts
-var import_ts_morph48 = require("ts-morph");
+var import_ts_morph49 = require("ts-morph");
 function tryMatchJsxReturn(node, pattern) {
   let expr;
   let source;
-  if (import_ts_morph48.Node.isReturnStatement(node)) {
+  if (import_ts_morph49.Node.isReturnStatement(node)) {
     expr = node.getExpression();
     source = node;
-  } else if (import_ts_morph48.Node.isArrowFunction(node)) {
+  } else if (import_ts_morph49.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph48.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph49.Node.isBlock(body)) {
       expr = body;
       source = body;
     }
@@ -11007,14 +11133,14 @@ function tryMatchJsxReturn(node, pattern) {
   return { node, source, terminal };
 }
 function componentTargetOf(tagNode) {
-  if (!import_ts_morph48.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+  if (!import_ts_morph49.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
     return null;
   }
   const target = functionTargetOf(tagNode);
   return target === null ? null : { file: target.file, name: target.name };
 }
 function jsxToRenderNode(node) {
-  if (import_ts_morph48.Node.isJsxElement(node)) {
+  if (import_ts_morph49.Node.isJsxElement(node)) {
     const opening = node.getOpeningElement();
     const tag = opening.getTagNameNode().getText();
     const attrs = collectJsxAttributes(opening);
@@ -11028,7 +11154,7 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph48.Node.isJsxSelfClosingElement(node)) {
+  if (import_ts_morph49.Node.isJsxSelfClosingElement(node)) {
     const tag = node.getTagNameNode().getText();
     const attrs = collectJsxAttributes(node);
     const target = componentTargetOf(node.getTagNameNode());
@@ -11040,11 +11166,11 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph48.Node.isJsxFragment(node)) {
+  if (import_ts_morph49.Node.isJsxFragment(node)) {
     const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
     return { type: "element", tag: "Fragment", children };
   }
-  if (import_ts_morph48.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph49.Node.isParenthesizedExpression(node)) {
     return jsxToRenderNode(node.getExpression());
   }
   return null;
@@ -11052,12 +11178,12 @@ function jsxToRenderNode(node) {
 function collectJsxAttributes(opening) {
   const entries = {};
   for (const attr of opening.getAttributes()) {
-    if (import_ts_morph48.Node.isJsxSpreadAttribute(attr)) {
+    if (import_ts_morph49.Node.isJsxSpreadAttribute(attr)) {
       const exprText = attr.getExpression().getText();
       entries[`...${exprText}`] = exprText;
       continue;
     }
-    if (!import_ts_morph48.Node.isJsxAttribute(attr)) {
+    if (!import_ts_morph49.Node.isJsxAttribute(attr)) {
       continue;
     }
     const name = attr.getNameNode().getText();
@@ -11066,7 +11192,7 @@ function collectJsxAttributes(opening) {
       entries[name] = "";
       continue;
     }
-    if (import_ts_morph48.Node.isJsxExpression(initializer)) {
+    if (import_ts_morph49.Node.isJsxExpression(initializer)) {
       const inner = initializer.getExpression();
       entries[name] = inner !== void 0 ? inner.getText() : "";
       continue;
@@ -11076,30 +11202,30 @@ function collectJsxAttributes(opening) {
   return Object.keys(entries).length > 0 ? entries : null;
 }
 function jsxChildToRenderNode(child) {
-  if (import_ts_morph48.Node.isJsxText(child)) {
+  if (import_ts_morph49.Node.isJsxText(child)) {
     const text = child.getLiteralText().trim();
     if (text.length === 0) {
       return null;
     }
     return { type: "text", value: text };
   }
-  if (import_ts_morph48.Node.isJsxExpression(child)) {
+  if (import_ts_morph49.Node.isJsxExpression(child)) {
     const inner = child.getExpression();
     if (inner === void 0) {
       return null;
     }
     return jsxExpressionToRenderNode(inner);
   }
-  if (import_ts_morph48.Node.isJsxElement(child) || import_ts_morph48.Node.isJsxSelfClosingElement(child) || import_ts_morph48.Node.isJsxFragment(child)) {
+  if (import_ts_morph49.Node.isJsxElement(child) || import_ts_morph49.Node.isJsxSelfClosingElement(child) || import_ts_morph49.Node.isJsxFragment(child)) {
     return jsxToRenderNode(child);
   }
   return null;
 }
 function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph48.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph49.Node.isParenthesizedExpression(expr)) {
     return jsxExpressionToRenderNode(expr.getExpression());
   }
-  if (import_ts_morph48.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph49.Node.isBinaryExpression(expr)) {
     const op = expr.getOperatorToken().getText();
     if (op === "&&") {
       const right = renderAlternative(peelParens(expr.getRight()));
@@ -11113,7 +11239,7 @@ function jsxExpressionToRenderNode(expr) {
       }
     }
   }
-  if (import_ts_morph48.Node.isConditionalExpression(expr)) {
+  if (import_ts_morph49.Node.isConditionalExpression(expr)) {
     const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
     const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
     if (truthy.kind === "jsx") {
@@ -11136,16 +11262,16 @@ function jsxExpressionToRenderNode(expr) {
   return { type: "expression", sourceText: expr.getText() };
 }
 function renderAlternative(node) {
-  if (import_ts_morph48.Node.isNullLiteral(node)) {
+  if (import_ts_morph49.Node.isNullLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isFalseLiteral(node)) {
+  if (import_ts_morph49.Node.isFalseLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isIdentifier(node) && node.getText() === "undefined") {
+  if (import_ts_morph49.Node.isIdentifier(node) && node.getText() === "undefined") {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isJsxElement(node) || import_ts_morph48.Node.isJsxSelfClosingElement(node) || import_ts_morph48.Node.isJsxFragment(node)) {
+  if (import_ts_morph49.Node.isJsxElement(node) || import_ts_morph49.Node.isJsxSelfClosingElement(node) || import_ts_morph49.Node.isJsxFragment(node)) {
     const tree = jsxToRenderNode(node);
     if (tree !== null) {
       return { kind: "jsx", node: tree };
@@ -11155,13 +11281,13 @@ function renderAlternative(node) {
 }
 
 // src/terminals/returns.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 
 // src/terminals/helperResolution.ts
-var import_ts_morph49 = require("ts-morph");
+var import_ts_morph50 = require("ts-morph");
 function resolveHelperReturn(call, resolveCallee2) {
   const callee = call.getExpression();
-  if (!import_ts_morph49.Node.isIdentifier(callee)) {
+  if (!import_ts_morph50.Node.isIdentifier(callee)) {
     return { kind: "notLocal" };
   }
   const helper = memoizedLocalHelper(callee, resolveCallee2);
@@ -11191,16 +11317,16 @@ function guardsAbove(returnValue) {
   let child = returnValue;
   let current2 = returnValue.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph49.Node.isIfStatement(current2)) {
+    if (import_ts_morph50.Node.isIfStatement(current2)) {
       guards.push({
         condition: current2.getExpression(),
         whenTrue: current2.getThenStatement() === child
       });
     }
-    if (import_ts_morph49.Node.isBlock(current2)) {
+    if (import_ts_morph50.Node.isBlock(current2)) {
       guards.push(...earlyReturnGuardsBefore(current2, child));
     }
-    if (import_ts_morph49.Node.isFunctionDeclaration(current2) || import_ts_morph49.Node.isArrowFunction(current2) || import_ts_morph49.Node.isFunctionExpression(current2)) {
+    if (import_ts_morph50.Node.isFunctionDeclaration(current2) || import_ts_morph50.Node.isArrowFunction(current2) || import_ts_morph50.Node.isFunctionExpression(current2)) {
       break;
     }
     child = current2;
@@ -11209,7 +11335,7 @@ function guardsAbove(returnValue) {
   return guards;
 }
 function earlyReturnGuardsBefore(block, child) {
-  if (!import_ts_morph49.Node.isBlock(block)) {
+  if (!import_ts_morph50.Node.isBlock(block)) {
     return [];
   }
   const guards = [];
@@ -11217,7 +11343,7 @@ function earlyReturnGuardsBefore(block, child) {
     if (statement === child) {
       break;
     }
-    if (!import_ts_morph49.Node.isIfStatement(statement) || statement.getElseStatement()) {
+    if (!import_ts_morph50.Node.isIfStatement(statement) || statement.getElseStatement()) {
       continue;
     }
     if (alwaysReturns(statement.getThenStatement())) {
@@ -11227,10 +11353,10 @@ function earlyReturnGuardsBefore(block, child) {
   return guards;
 }
 function alwaysReturns(statement) {
-  if (import_ts_morph49.Node.isReturnStatement(statement) || import_ts_morph49.Node.isThrowStatement(statement)) {
+  if (import_ts_morph50.Node.isReturnStatement(statement) || import_ts_morph50.Node.isThrowStatement(statement)) {
     return true;
   }
-  if (!import_ts_morph49.Node.isBlock(statement)) {
+  if (!import_ts_morph50.Node.isBlock(statement)) {
     return false;
   }
   const statements = statement.getStatements();
@@ -11248,7 +11374,7 @@ var COMPARISONS = {
   "!=": (a, b) => a !== b
 };
 function evaluateComparison(condition, substitutions) {
-  if (!import_ts_morph49.Node.isBinaryExpression(condition)) {
+  if (!import_ts_morph50.Node.isBinaryExpression(condition)) {
     return null;
   }
   const left = numberFor(condition.getLeft(), substitutions);
@@ -11260,8 +11386,8 @@ function evaluateComparison(condition, substitutions) {
   return compare === void 0 ? null : compare(left, right);
 }
 function numberFor(node, substitutions) {
-  const resolved = import_ts_morph49.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
-  return import_ts_morph49.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
+  const resolved = import_ts_morph50.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
+  return import_ts_morph50.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
 }
 var helperBySymbol = /* @__PURE__ */ new WeakMap();
 function memoizedLocalHelper(callee, resolveCallee2) {
@@ -11327,8 +11453,8 @@ function implementationBeside(declaration, name) {
         return candidate;
       }
     }
-    const variable4 = source.getVariableDeclaration(name);
-    const fn = variable4 === void 0 ? null : asFunctionLike(variable4);
+    const variable3 = source.getVariableDeclaration(name);
+    const fn = variable3 === void 0 ? null : asFunctionLike(variable3);
     if (fn !== null) {
       return fn;
     }
@@ -11348,12 +11474,12 @@ function declarationsFor(callee, resolveCallee2) {
   return (aliased ?? symbol).getDeclarations();
 }
 function asFunctionLike(declaration) {
-  if (import_ts_morph49.Node.isFunctionDeclaration(declaration) || import_ts_morph49.Node.isArrowFunction(declaration) || import_ts_morph49.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph50.Node.isFunctionDeclaration(declaration) || import_ts_morph50.Node.isArrowFunction(declaration) || import_ts_morph50.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (import_ts_morph49.Node.isVariableDeclaration(declaration)) {
+  if (import_ts_morph50.Node.isVariableDeclaration(declaration)) {
     const initializer = declaration.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph49.Node.isArrowFunction(initializer) || import_ts_morph49.Node.isFunctionExpression(initializer))) {
+    if (initializer !== void 0 && (import_ts_morph50.Node.isArrowFunction(initializer) || import_ts_morph50.Node.isFunctionExpression(initializer))) {
       return initializer;
     }
   }
@@ -11364,13 +11490,13 @@ function returnedObjects(fn) {
   if (body === void 0) {
     return [];
   }
-  if (!import_ts_morph49.Node.isBlock(body)) {
+  if (!import_ts_morph50.Node.isBlock(body)) {
     const expression = peelParens(body);
-    return import_ts_morph49.Node.isObjectLiteralExpression(expression) ? [expression] : [];
+    return import_ts_morph50.Node.isObjectLiteralExpression(expression) ? [expression] : [];
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    import_ts_morph49.SyntaxKind.ReturnStatement
+    import_ts_morph50.SyntaxKind.ReturnStatement
   )) {
     if (enclosingFunctionOf(statement) !== body) {
       continue;
@@ -11380,7 +11506,7 @@ function returnedObjects(fn) {
       continue;
     }
     const unwrapped2 = peelParens(expression);
-    if (import_ts_morph49.Node.isObjectLiteralExpression(unwrapped2)) {
+    if (import_ts_morph50.Node.isObjectLiteralExpression(unwrapped2)) {
       found.push(unwrapped2);
     }
   }
@@ -11389,7 +11515,7 @@ function returnedObjects(fn) {
 function enclosingFunctionOf(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph49.Node.isFunctionDeclaration(current2) || import_ts_morph49.Node.isArrowFunction(current2) || import_ts_morph49.Node.isFunctionExpression(current2) || import_ts_morph49.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph50.Node.isFunctionDeclaration(current2) || import_ts_morph50.Node.isArrowFunction(current2) || import_ts_morph50.Node.isFunctionExpression(current2) || import_ts_morph50.Node.isMethodDeclaration(current2)) {
       return current2.getBody();
     }
     current2 = current2.getParent();
@@ -11408,7 +11534,7 @@ function bindArguments(callArgs, params) {
 }
 
 // src/terminals/statusBranches.ts
-var import_ts_morph50 = require("ts-morph");
+var import_ts_morph51 = require("ts-morph");
 var import_values6 = require("@suss/values");
 function statusChoicesOf(argument, resolution) {
   const chosen = asConditional(argument);
@@ -11432,10 +11558,10 @@ function asConditional(node) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph50.Node.isIdentifier(node)) {
+  if (!import_ts_morph51.Node.isIdentifier(node)) {
     return null;
   }
-  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph50.Node.isVariableDeclaration);
+  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph51.Node.isVariableDeclaration);
   if (declaration === void 0) {
     return null;
   }
@@ -11446,7 +11572,7 @@ function asConditional(node) {
   const only = written.values[0];
   return only === void 0 ? null : toConditional(only);
 }
-var toConditional = (node) => import_ts_morph50.Node.isConditionalExpression(node) ? node : null;
+var toConditional = (node) => import_ts_morph51.Node.isConditionalExpression(node) ? node : null;
 function numberOf(node, resolution) {
   const value = (0, import_values6.constantOf)(evaluatedValue(node, resolution));
   return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -11463,7 +11589,7 @@ function unwrapMethodChain(call, match, func) {
   for (let i = methodChain.length - 1; i >= 0; i--) {
     const expectedMethod = methodChain[i];
     const callee = current2.getExpression();
-    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph52.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     if (callee.getName() !== expectedMethod) {
@@ -11479,7 +11605,7 @@ function unwrapMethodChain(call, match, func) {
         return null;
       }
     } else {
-      if (!import_ts_morph51.Node.isCallExpression(subject)) {
+      if (!import_ts_morph52.Node.isCallExpression(subject)) {
         return null;
       }
       current2 = subject;
@@ -11489,9 +11615,9 @@ function unwrapMethodChain(call, match, func) {
 }
 function withoutPassThroughCalls(subject, passThrough) {
   let current2 = subject;
-  while (import_ts_morph51.Node.isCallExpression(current2)) {
+  while (import_ts_morph52.Node.isCallExpression(current2)) {
     const callee = current2.getExpression();
-    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
+    if (!import_ts_morph52.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
       break;
     }
     current2 = callee.getExpression();
@@ -11503,12 +11629,12 @@ function returnedValueOf(returnStatement) {
   return written === void 0 ? null : unwrapValue(written);
 }
 function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
-  if (import_ts_morph51.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph52.Node.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
       return [];
     }
-    if (import_ts_morph51.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
+    if (import_ts_morph52.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
       return [];
     }
     const terminal = terminalFromReturnedObject(
@@ -11521,14 +11647,14 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
-  if (!import_ts_morph51.Node.isReturnStatement(node)) {
+  if (!import_ts_morph52.Node.isReturnStatement(node)) {
     return [];
   }
   const returned = returnedValueOf(node);
   if (returned === null) {
     return [];
   }
-  if (import_ts_morph51.Node.isObjectLiteralExpression(returned)) {
+  if (import_ts_morph52.Node.isObjectLiteralExpression(returned)) {
     const terminal = terminalFromReturnedObject(
       returned,
       node,
@@ -11539,7 +11665,7 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [terminal];
   }
-  if (!import_ts_morph51.Node.isCallExpression(returned)) {
+  if (!import_ts_morph52.Node.isCallExpression(returned)) {
     return [];
   }
   const resolved = resolveHelperReturn(returned, resolveCallee2);
@@ -11576,7 +11702,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   if (required !== void 0 && required.length > 0) {
     const presentNames = /* @__PURE__ */ new Set();
     for (const prop of obj.getProperties()) {
-      if (import_ts_morph51.Node.isPropertyAssignment(prop) || import_ts_morph51.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph52.Node.isPropertyAssignment(prop) || import_ts_morph52.Node.isShorthandPropertyAssignment(prop)) {
         presentNames.add(prop.getName());
       }
     }
@@ -11602,7 +11728,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
     // When a helper built the value, the anchor is the caller's own
     // return, so it doubles as the provenance. A value reached any other
     // way leaves this unset and its caller fills it in.
-    ...import_ts_morph51.Node.isReturnStatement(anchor) ? { source: anchor } : {},
+    ...import_ts_morph52.Node.isReturnStatement(anchor) ? { source: anchor } : {},
     terminal: {
       kind: pattern.kind,
       statusCode,
@@ -11621,7 +11747,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   };
 }
 function tryMatchParameterMethodCall(node, func, pattern, match, resolution) {
-  if (!import_ts_morph51.Node.isCallExpression(node)) {
+  if (!import_ts_morph52.Node.isCallExpression(node)) {
     return [];
   }
   const result = unwrapMethodChain(node, match, func);
@@ -11681,7 +11807,7 @@ function statusArgument(calls, extraction) {
 }
 function returnCoveredByParameterMethodCall(expr, func, patterns) {
   const current2 = unwrapValue(expr);
-  if (!import_ts_morph51.Node.isCallExpression(current2)) {
+  if (!import_ts_morph52.Node.isCallExpression(current2)) {
     return false;
   }
   for (const pattern of patterns) {
@@ -11697,7 +11823,7 @@ function returnCoveredByParameterMethodCall(expr, func, patterns) {
 }
 function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   const match = pattern.match.type === "returnStatement" ? pattern.match : null;
-  if (import_ts_morph51.Node.isReturnStatement(node)) {
+  if (import_ts_morph52.Node.isReturnStatement(node)) {
     const expr = node.getExpression();
     if (match?.excludeCallReturns === true) {
       if (expr === void 0) {
@@ -11716,9 +11842,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
     }
     return buildReturnTerminal(node, pattern, body);
   }
-  if (import_ts_morph51.Node.isArrowFunction(node)) {
+  if (import_ts_morph52.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body === void 0 || import_ts_morph51.Node.isBlock(body)) {
+    if (body === void 0 || import_ts_morph52.Node.isBlock(body)) {
       return null;
     }
     const shape = extractShape(body);
@@ -11776,20 +11902,20 @@ function unresolvedTerminal(kind, node) {
   };
 }
 function calleeSubject(callee) {
-  if (import_ts_morph51.Node.isIdentifier(callee)) {
+  if (import_ts_morph52.Node.isIdentifier(callee)) {
     return callee;
   }
-  if (import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph52.Node.isPropertyAccessExpression(callee)) {
     const subject = callee.getExpression();
-    return import_ts_morph51.Node.isIdentifier(subject) ? subject : null;
+    return import_ts_morph52.Node.isIdentifier(subject) ? subject : null;
   }
   return null;
 }
 function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom) {
-  if (!import_ts_morph51.Node.isCallExpression(node) && !import_ts_morph51.Node.isNewExpression(node)) {
+  if (!import_ts_morph52.Node.isCallExpression(node) && !import_ts_morph52.Node.isNewExpression(node)) {
     return null;
   }
-  if (import_ts_morph51.Node.isNewExpression(node) && returnPositionOf(node) === null) {
+  if (import_ts_morph52.Node.isNewExpression(node) && returnPositionOf(node) === null) {
     return null;
   }
   const callee = node.getExpression();
@@ -11828,9 +11954,9 @@ function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom)
 }
 
 // src/terminals/throws.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 function tryMatchThrowExpression(node, pattern, match, resolution) {
-  if (!import_ts_morph52.Node.isThrowStatement(node)) {
+  if (!import_ts_morph53.Node.isThrowStatement(node)) {
     return null;
   }
   const thrownExpr = node.getExpression();
@@ -11872,17 +11998,17 @@ function extractThrowMessage(callArgs) {
     return null;
   }
   for (const arg of callArgs) {
-    if (import_ts_morph52.Node.isStringLiteral(arg) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(arg)) {
+    if (import_ts_morph53.Node.isStringLiteral(arg) || import_ts_morph53.Node.isNoSubstitutionTemplateLiteral(arg)) {
       return arg.getLiteralValue();
     }
-    if (import_ts_morph52.Node.isTemplateExpression(arg)) {
+    if (import_ts_morph53.Node.isTemplateExpression(arg)) {
       return arg.getText();
     }
   }
   return null;
 }
 function classifyThrownExpression(thrown, constructorPattern) {
-  if (import_ts_morph52.Node.isCallExpression(thrown) || import_ts_morph52.Node.isNewExpression(thrown)) {
+  if (import_ts_morph53.Node.isCallExpression(thrown) || import_ts_morph53.Node.isNewExpression(thrown)) {
     const calleeText = thrown.getExpression().getText();
     if (constructorPattern !== void 0 && !calleeText.startsWith(constructorPattern)) {
       return null;
@@ -11969,9 +12095,9 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, origi
       }
     }
   });
-  if (results.length === 0 && import_ts_morph53.Node.isArrowFunction(func)) {
+  if (results.length === 0 && import_ts_morph54.Node.isArrowFunction(func)) {
     const body = func.getBody();
-    if (body !== void 0 && !import_ts_morph53.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph54.Node.isBlock(body)) {
       for (const pattern of patterns) {
         let found = null;
         if (pattern.match.type === "parameterMethodCall") {
@@ -12006,7 +12132,7 @@ function functionMayFallThrough(func) {
   if (body === void 0) {
     return false;
   }
-  if (!import_ts_morph53.Node.isBlock(body)) {
+  if (!import_ts_morph54.Node.isBlock(body)) {
     return false;
   }
   const statements = body.getStatements();
@@ -12014,7 +12140,7 @@ function functionMayFallThrough(func) {
     return true;
   }
   const last = statements[statements.length - 1];
-  if (import_ts_morph53.Node.isReturnStatement(last) || import_ts_morph53.Node.isThrowStatement(last)) {
+  if (import_ts_morph54.Node.isReturnStatement(last) || import_ts_morph54.Node.isThrowStatement(last)) {
     return false;
   }
   return true;
@@ -12062,7 +12188,7 @@ function writesTerminal(call, terminalNodes) {
   }
 }
 function isReceiverOf(node, parent) {
-  return (import_ts_morph54.Node.isPropertyAccessExpression(parent) || import_ts_morph54.Node.isElementAccessExpression(parent) || import_ts_morph54.Node.isCallExpression(parent)) && parent.getExpression() === node;
+  return (import_ts_morph55.Node.isPropertyAccessExpression(parent) || import_ts_morph55.Node.isElementAccessExpression(parent) || import_ts_morph55.Node.isCallExpression(parent)) && parent.getExpression() === node;
 }
 var isDefaultConditionList = (conditions) => conditions.length === 0 || conditions.every(
   (c) => c.source === "earlyReturn" || c.source === "earlyThrow"
@@ -12072,7 +12198,7 @@ function bodyContentOf(func) {
   if (body === void 0) {
     return "absent";
   }
-  if (!import_ts_morph54.Node.isBlock(body)) {
+  if (!import_ts_morph55.Node.isBlock(body)) {
     return "statements";
   }
   return body.getStatements().length === 0 ? "empty" : "statements";
@@ -12088,7 +12214,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       claimed.add(source);
     }
   }
-  if (import_ts_morph54.Node.isArrowFunction(func) && import_ts_morph54.Node.isExpression(body)) {
+  if (import_ts_morph55.Node.isArrowFunction(func) && import_ts_morph55.Node.isExpression(body)) {
     return claimed.has(body) ? 0 : 1;
   }
   let unmatched = 0;
@@ -12101,7 +12227,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph54.Node.isReturnStatement(node)) {
+    if (!import_ts_morph55.Node.isReturnStatement(node)) {
       return;
     }
     if (node.getExpression() === void 0) {
@@ -12254,7 +12380,7 @@ function accountFor(site, terminalNodes, branches) {
 }
 
 // src/bootstrap/sourceFileLookup.ts
-var import_ts_morph55 = require("ts-morph");
+var import_ts_morph56 = require("ts-morph");
 function createSourceFileLookup(project) {
   const all = project.getSourceFiles();
   const byAbs = /* @__PURE__ */ new Map();
@@ -12316,7 +12442,7 @@ function spanKey(span) {
 function indexFunctions(sf) {
   const index = /* @__PURE__ */ new Map();
   sf.forEachDescendant((node) => {
-    if (!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 (!import_ts_morph56.Node.isFunctionDeclaration(node) && !import_ts_morph56.Node.isFunctionExpression(node) && !import_ts_morph56.Node.isArrowFunction(node) && !import_ts_morph56.Node.isMethodDeclaration(node)) {
       return;
     }
     const bySpan = spanKey({ start: node.getStart(), end: node.getEnd() });
@@ -12330,13 +12456,13 @@ function indexFunctions(sf) {
 }
 
 // src/contract.ts
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 function extractDeclaredBody(node) {
   if (node === void 0) {
     return null;
   }
-  if (!import_ts_morph56.Node.isCallExpression(node)) {
+  if (!import_ts_morph57.Node.isCallExpression(node)) {
     return null;
   }
   const typeArgs = node.getTypeArguments();
@@ -12350,10 +12476,10 @@ function resolveHandlerPropNode(func) {
   if (parent === void 0) {
     return null;
   }
-  if (import_ts_morph56.Node.isPropertyAssignment(parent)) {
+  if (import_ts_morph57.Node.isPropertyAssignment(parent)) {
     return parent;
   }
-  if (import_ts_morph56.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph57.Node.isMethodDeclaration(func)) {
     return func;
   }
   return null;
@@ -12365,11 +12491,11 @@ function findRouterCall(unit) {
     return null;
   }
   const handlersObj = propNode.getParent();
-  if (handlersObj === void 0 || !import_ts_morph56.Node.isObjectLiteralExpression(handlersObj)) {
+  if (handlersObj === void 0 || !import_ts_morph57.Node.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
   const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !import_ts_morph56.Node.isCallExpression(routerCall)) {
+  if (routerCall === void 0 || !import_ts_morph57.Node.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -12382,17 +12508,17 @@ function findRouterCall(unit) {
   };
 }
 function resolveContractObject(contractArg, resolution) {
-  if (import_ts_morph56.Node.isObjectLiteralExpression(contractArg)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(contractArg)) {
     return contractArg;
   }
-  if (import_ts_morph56.Node.isPropertyAccessExpression(contractArg)) {
+  if (import_ts_morph57.Node.isPropertyAccessExpression(contractArg)) {
     const base = resolveContractObject(contractArg.getExpression(), resolution);
-    if (base === null || !import_ts_morph56.Node.isObjectLiteralExpression(base)) {
+    if (base === null || !import_ts_morph57.Node.isObjectLiteralExpression(base)) {
       return null;
     }
     const propName = contractArg.getName();
     for (const prop of base.getProperties()) {
-      if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
         continue;
       }
       if (prop.getName() !== propName) {
@@ -12402,20 +12528,20 @@ function resolveContractObject(contractArg, resolution) {
       if (value === void 0) {
         return null;
       }
-      if (import_ts_morph56.Node.isObjectLiteralExpression(value)) {
+      if (import_ts_morph57.Node.isObjectLiteralExpression(value)) {
         return value;
       }
-      if (import_ts_morph56.Node.isIdentifier(value) || import_ts_morph56.Node.isPropertyAccessExpression(value)) {
+      if (import_ts_morph57.Node.isIdentifier(value) || import_ts_morph57.Node.isPropertyAccessExpression(value)) {
         return resolveContractObject(value, resolution);
       }
-      if (import_ts_morph56.Node.isCallExpression(value)) {
+      if (import_ts_morph57.Node.isCallExpression(value)) {
         return unwrapContractInit(value);
       }
       return null;
     }
     return null;
   }
-  if (!import_ts_morph56.Node.isIdentifier(contractArg)) {
+  if (!import_ts_morph57.Node.isIdentifier(contractArg)) {
     return null;
   }
   const symbol = contractArg.getSymbol();
@@ -12427,7 +12553,7 @@ function resolveContractObject(contractArg, resolution) {
     return null;
   }
   const decl = decls[0];
-  if (import_ts_morph56.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph57.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sourceFile = importDecl.getModuleSpecifierSourceFile();
     if (sourceFile !== void 0 && resolution !== void 0) {
@@ -12436,14 +12562,14 @@ function resolveContractObject(contractArg, resolution) {
       );
       if (exported !== void 0 && exported.length > 0) {
         const exportedDecl = exported[0];
-        if (import_ts_morph56.Node.isVariableDeclaration(exportedDecl)) {
+        if (import_ts_morph57.Node.isVariableDeclaration(exportedDecl)) {
           return unwrapContractInit(exportedDecl.getInitializer());
         }
       }
     }
     return null;
   }
-  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
     return unwrapContractInit(decl.getInitializer());
   }
   return null;
@@ -12453,39 +12579,39 @@ function unwrapContractInit(init) {
     return null;
   }
   const node = peelSyntax(init);
-  if (import_ts_morph56.Node.isCallExpression(node)) {
+  if (import_ts_morph57.Node.isCallExpression(node)) {
     const args = node.getArguments();
-    if (args.length > 0 && import_ts_morph56.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length > 0 && import_ts_morph57.Node.isObjectLiteralExpression(args[0])) {
       return args[0];
     }
     return null;
   }
-  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
     return node;
   }
   return null;
 }
 function extractEndpointContract(endpointNode, pattern, framework, resolution) {
-  if (!import_ts_morph56.Node.isObjectLiteralExpression(endpointNode)) {
+  if (!import_ts_morph57.Node.isObjectLiteralExpression(endpointNode)) {
     return null;
   }
   const responses = [];
   let method;
   let path15;
   for (const prop of endpointNode.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const propName = prop.getName();
     if (propName === pattern.methodProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
         method = val.getLiteralValue();
       }
     }
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
         path15 = val.getLiteralValue();
       }
     }
@@ -12494,7 +12620,7 @@ function extractEndpointContract(endpointNode, pattern, framework, resolution) {
       const val = written === void 0 ? null : objectLiteralOf(written, resolution);
       if (val !== null) {
         for (const respProp of propertiesOf(val, resolution)) {
-          if (!import_ts_morph56.Node.isPropertyAssignment(respProp)) {
+          if (!import_ts_morph57.Node.isPropertyAssignment(respProp)) {
             continue;
           }
           const statusStr = respProp.getName();
@@ -12544,11 +12670,11 @@ function readContract(unit, pattern, framework, resolution) {
     return null;
   }
   const contractObj = resolveContractObject(routerInfo.contractArg, resolution);
-  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== routerInfo.handlerName) {
@@ -12573,7 +12699,7 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   const call = func.getParent();
-  if (call === void 0 || !import_ts_morph56.Node.isCallExpression(call)) {
+  if (call === void 0 || !import_ts_morph57.Node.isCallExpression(call)) {
     return null;
   }
   const args = call.getArguments();
@@ -12585,24 +12711,24 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   let node = arg;
-  while (import_ts_morph56.Node.isAsExpression(node)) {
+  while (import_ts_morph57.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
-  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
     return node;
   }
-  if (import_ts_morph56.Node.isCallExpression(node)) {
+  if (import_ts_morph57.Node.isCallExpression(node)) {
     return unwrapContractInit(node);
   }
   return resolveContractObject(node, resolution);
 }
 function readContractForClientCall(callExpression, methodName, pattern, framework, resolution) {
-  const callee = import_ts_morph56.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
-  if (callee === null || !import_ts_morph56.Node.isPropertyAccessExpression(callee)) {
+  const callee = import_ts_morph57.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
+  if (callee === null || !import_ts_morph57.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   const clientIdentifier = callee.getExpression();
-  if (!import_ts_morph56.Node.isIdentifier(clientIdentifier)) {
+  if (!import_ts_morph57.Node.isIdentifier(clientIdentifier)) {
     return null;
   }
   const symbol = clientIdentifier.getSymbol();
@@ -12614,11 +12740,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const decl = decls[0];
-  if (!import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (!import_ts_morph57.Node.isVariableDeclaration(decl)) {
     return null;
   }
   const init = decl.getInitializer();
-  if (init === void 0 || !import_ts_morph56.Node.isCallExpression(init)) {
+  if (init === void 0 || !import_ts_morph57.Node.isCallExpression(init)) {
     return null;
   }
   const args = init.getArguments();
@@ -12626,11 +12752,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const contractObj = resolveContractObject(args[0], resolution);
-  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== methodName) {
@@ -12652,26 +12778,26 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
 
 // src/diagnostics.ts
 var import_node_path7 = __toESM(require("path"), 1);
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 var import_extractor6 = require("@suss/extractor");
 var DEFAULT_RESOLUTION = {
-  moduleResolution: import_ts_morph57.ts.ModuleResolutionKind.Bundler,
-  target: import_ts_morph57.ts.ScriptTarget.ESNext,
-  module: import_ts_morph57.ts.ModuleKind.ESNext
+  moduleResolution: import_ts_morph58.ts.ModuleResolutionKind.Bundler,
+  target: import_ts_morph58.ts.ScriptTarget.ESNext,
+  module: import_ts_morph58.ts.ModuleKind.ESNext
 };
 function resolutionContext(args) {
   if (args.tsConfigFilePath !== void 0) {
-    const configFile = import_ts_morph57.ts.readConfigFile(
+    const configFile = import_ts_morph58.ts.readConfigFile(
       args.tsConfigFilePath,
-      import_ts_morph57.ts.sys.readFile
+      import_ts_morph58.ts.sys.readFile
     );
     if (configFile.error !== void 0) {
       return null;
     }
     const dir = import_node_path7.default.dirname(args.tsConfigFilePath);
-    const parsed = import_ts_morph57.ts.parseJsonConfigFileContent(
+    const parsed = import_ts_morph58.ts.parseJsonConfigFileContent(
       configFile.config,
-      import_ts_morph57.ts.sys,
+      import_ts_morph58.ts.sys,
       dir,
       /*existingOptions*/
       void 0,
@@ -12700,11 +12826,11 @@ function unresolvedGatesFor(gates, args) {
   }
   const unresolved = [];
   for (const gate of gates) {
-    const resolved = import_ts_morph57.ts.resolveModuleName(
+    const resolved = import_ts_morph58.ts.resolveModuleName(
       gate,
       context.containingFile,
       context.options,
-      import_ts_morph57.ts.sys
+      import_ts_morph58.ts.sys
     );
     if (resolved.resolvedModule === void 0) {
       unresolved.push(gate);
@@ -12877,7 +13003,7 @@ var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 var import_graphql2 = require("graphql");
 var import_picomatch2 = __toESM(require("picomatch"), 1);
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
 function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const scopes = compileOperationScopes(packs);
@@ -12917,11 +13043,11 @@ function fragmentsRegisteredIn(sourceFiles) {
   const registered = /* @__PURE__ */ new Set();
   for (const sourceFile of sourceFiles) {
     sourceFile.forEachDescendant((node) => {
-      if (!import_ts_morph58.Node.isCallExpression(node)) {
+      if (!import_ts_morph59.Node.isCallExpression(node)) {
         return;
       }
       const argument = node.getArguments()[0];
-      if (argument === void 0 || !import_ts_morph58.Node.isNoSubstitutionTemplateLiteral(argument)) {
+      if (argument === void 0 || !import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(argument)) {
         return;
       }
       for (const name of fragmentOnlyDocumentNames(argument.getLiteralText())) {
@@ -13108,7 +13234,7 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheConstruction === null) {
     return "unknown";
   }
-  if (!import_ts_morph58.Node.isNewExpression(cacheConstruction) && !import_ts_morph58.Node.isCallExpression(cacheConstruction)) {
+  if (!import_ts_morph59.Node.isNewExpression(cacheConstruction) && !import_ts_morph59.Node.isCallExpression(cacheConstruction)) {
     return "unknown";
   }
   const args = cacheConstruction.getArguments();
@@ -13122,15 +13248,15 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheOptions.getProperty(spec.registryProperty) !== void 0) {
     return "configured";
   }
-  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph58.Node.isSpreadAssignment(property));
+  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph59.Node.isSpreadAssignment(property));
   return hasSpread ? "unknown" : "absent";
 }
 function firstArgumentObjectLiteral(construction) {
-  if (!import_ts_morph58.Node.isNewExpression(construction) && !import_ts_morph58.Node.isCallExpression(construction)) {
+  if (!import_ts_morph59.Node.isNewExpression(construction) && !import_ts_morph59.Node.isCallExpression(construction)) {
     return null;
   }
   const arg = construction.getArguments()[0];
-  if (arg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !import_ts_morph59.Node.isObjectLiteralExpression(arg)) {
     return null;
   }
   return arg;
@@ -13140,10 +13266,10 @@ function propertyValueOf2(options, name) {
   if (property === void 0) {
     return null;
   }
-  if (import_ts_morph58.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph59.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph58.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph59.Node.isShorthandPropertyAssignment(property)) {
     const symbol = property.getProject().getTypeChecker().getShorthandAssignmentValueSymbol(property);
     return symbol?.getValueDeclaration() ?? null;
   }
@@ -13153,13 +13279,13 @@ function resolveToConstructionOf(expression, cacheClass) {
   let current2 = expression;
   for (let hop = 0; hop < 4 && current2 !== void 0; hop += 1) {
     current2 = unwrapExpression2(current2);
-    if (import_ts_morph58.Node.isVariableDeclaration(current2)) {
+    if (import_ts_morph59.Node.isVariableDeclaration(current2)) {
       current2 = current2.getInitializer();
       continue;
     }
-    if (import_ts_morph58.Node.isNewExpression(current2) || import_ts_morph58.Node.isCallExpression(current2)) {
+    if (import_ts_morph59.Node.isNewExpression(current2) || import_ts_morph59.Node.isCallExpression(current2)) {
       const callee = current2.getExpression();
-      if (callee === void 0 || !import_ts_morph58.Node.isIdentifier(callee)) {
+      if (callee === void 0 || !import_ts_morph59.Node.isIdentifier(callee)) {
         return null;
       }
       const local = localImportName(
@@ -13169,11 +13295,11 @@ function resolveToConstructionOf(expression, cacheClass) {
       );
       return local !== null && callee.getText() === local ? current2 : null;
     }
-    if (!import_ts_morph58.Node.isIdentifier(current2)) {
+    if (!import_ts_morph59.Node.isIdentifier(current2)) {
       return null;
     }
     const declaration = current2.getSymbol()?.getValueDeclaration();
-    if (declaration === void 0 || !import_ts_morph58.Node.isVariableDeclaration(declaration)) {
+    if (declaration === void 0 || !import_ts_morph59.Node.isVariableDeclaration(declaration)) {
       return null;
     }
     current2 = declaration.getInitializer();
@@ -13184,11 +13310,11 @@ function unwrapExpression2(node) {
   return peelSyntax(node);
 }
 function isConstructionNamed(node, localName) {
-  if (!import_ts_morph58.Node.isNewExpression(node) && !import_ts_morph58.Node.isCallExpression(node)) {
+  if (!import_ts_morph59.Node.isNewExpression(node) && !import_ts_morph59.Node.isCallExpression(node)) {
     return false;
   }
   const callee = node.getExpression();
-  return callee !== void 0 && import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === localName;
+  return callee !== void 0 && import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function localImportName(sourceFile, importModule, importName) {
   for (const one of namedImportsOf(sourceFile, [importModule], {
@@ -13202,11 +13328,11 @@ function localImportName(sourceFile, importModule, importName) {
 }
 function constructionRef(node, uriProperty, resolution) {
   const optionsArg = node.getArguments()[0];
-  if (optionsArg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg === void 0 || !import_ts_morph59.Node.isObjectLiteralExpression(optionsArg)) {
     return null;
   }
   const property = optionsArg.getProperty(uriProperty);
-  if (property === void 0 || !import_ts_morph58.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph59.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
@@ -13221,10 +13347,10 @@ function constructionRef(node, uriProperty, resolution) {
 }
 
 // src/discovery/helperIndex.ts
-var import_ts_morph60 = require("ts-morph");
+var import_ts_morph61 = require("ts-morph");
 
 // src/discovery/helperReading.ts
-var import_ts_morph59 = require("ts-morph");
+var import_ts_morph60 = require("ts-morph");
 var UNREAD = { as: "unread" };
 function readHelperSinks(helper) {
   const positions = parameterPositions(helper);
@@ -13234,11 +13360,11 @@ function readHelperSinks(helper) {
     return sinks;
   }
   body.forEachDescendant((node) => {
-    if (!import_ts_morph59.Node.isCallExpression(node)) {
+    if (!import_ts_morph60.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    const [method, receiver] = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
+    const [method, receiver] = import_ts_morph60.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
     sinks.push({
       method,
       receiver,
@@ -13258,25 +13384,25 @@ function parameterPositions(helper) {
   return positions;
 }
 function readValue(node, positions) {
-  if (import_ts_morph59.Node.isStringLiteral(node) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph60.Node.isStringLiteral(node) || import_ts_morph60.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { as: "text", text: node.getLiteralValue() };
   }
-  if (import_ts_morph59.Node.isTemplateExpression(node)) {
+  if (import_ts_morph60.Node.isTemplateExpression(node)) {
     return templateText(node, positions);
   }
-  if (import_ts_morph59.Node.isIdentifier(node)) {
+  if (import_ts_morph60.Node.isIdentifier(node)) {
     const position = positions.get(node.getText());
     return position === void 0 ? UNREAD : { as: "parameter", position };
   }
-  if (import_ts_morph59.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph60.Node.isPropertyAccessExpression(node)) {
     const target = node.getExpression();
-    const position = import_ts_morph59.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
+    const position = import_ts_morph60.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
     return position === void 0 ? UNREAD : { as: "parameter", position, property: node.getName() };
   }
-  if (import_ts_morph59.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph60.Node.isObjectLiteralExpression(node)) {
     return objectValue(node, positions);
   }
-  if (import_ts_morph59.Node.isCallExpression(node)) {
+  if (import_ts_morph60.Node.isCallExpression(node)) {
     return {
       as: "call",
       callee: node.getExpression().getText(),
@@ -13286,13 +13412,13 @@ function readValue(node, positions) {
   return UNREAD;
 }
 function templateText(node, positions) {
-  if (!import_ts_morph59.Node.isTemplateExpression(node)) {
+  if (!import_ts_morph60.Node.isTemplateExpression(node)) {
     return UNREAD;
   }
   let text = node.getHead().getLiteralText();
   for (const span of node.getTemplateSpans()) {
     const expression = span.getExpression();
-    const position = import_ts_morph59.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
+    const position = import_ts_morph60.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
     if (position === void 0) {
       return UNREAD;
     }
@@ -13301,12 +13427,12 @@ function templateText(node, positions) {
   return { as: "text", text };
 }
 function objectValue(node, positions) {
-  if (!import_ts_morph59.Node.isObjectLiteralExpression(node)) {
+  if (!import_ts_morph60.Node.isObjectLiteralExpression(node)) {
     return UNREAD;
   }
   const properties = {};
   for (const property of node.getProperties()) {
-    if (!import_ts_morph59.Node.isPropertyAssignment(property)) {
+    if (!import_ts_morph60.Node.isPropertyAssignment(property)) {
       continue;
     }
     const initializer = property.getInitializer();
@@ -13321,7 +13447,7 @@ function objectValue(node, positions) {
   return { as: "object", properties };
 }
 function propertyKey(name) {
-  return import_ts_morph59.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
+  return import_ts_morph60.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
 }
 
 // src/discovery/helperIndex.ts
@@ -13451,11 +13577,11 @@ function registrationMatchesOf(pack) {
 }
 function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph60.Node.isCallExpression(node)) {
+    if (!import_ts_morph61.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph60.Node.isIdentifier(callee)) {
+    if (!import_ts_morph61.Node.isIdentifier(callee)) {
       return;
     }
     const handedOver = subjectArgument(node, subjects, match, resolution);
@@ -13470,12 +13596,12 @@ function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   });
 }
 function subjectArgument(call, subjects, match, resolution) {
-  if (!import_ts_morph60.Node.isCallExpression(call)) {
+  if (!import_ts_morph61.Node.isCallExpression(call)) {
     return -1;
   }
   const args = call.getArguments();
   for (const [position, argument] of args.entries()) {
-    if (!import_ts_morph60.Node.isIdentifier(argument) && !import_ts_morph60.Node.isPropertyAccessExpression(argument)) {
+    if (!import_ts_morph61.Node.isIdentifier(argument) && !import_ts_morph61.Node.isPropertyAccessExpression(argument)) {
       continue;
     }
     if (subjectNodeFor(argument, subjects, match, resolution) !== void 0) {
@@ -13534,10 +13660,10 @@ function declaredFunctions(sourceFile) {
       found.push([name, declaration]);
     }
   }
-  for (const variable4 of sourceFile.getVariableDeclarations()) {
-    const initializer = variable4.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph60.Node.isArrowFunction(initializer) || import_ts_morph60.Node.isFunctionExpression(initializer))) {
-      found.push([variable4.getName(), initializer]);
+  for (const variable3 of sourceFile.getVariableDeclarations()) {
+    const initializer = variable3.getInitializer();
+    if (initializer !== void 0 && (import_ts_morph61.Node.isArrowFunction(initializer) || import_ts_morph61.Node.isFunctionExpression(initializer))) {
+      found.push([variable3.getName(), initializer]);
     }
   }
   return found;
@@ -13629,7 +13755,7 @@ function recordEdge(edgesByChild, candidate) {
 }
 
 // src/discovery/wrapperIndex.ts
-var import_ts_morph61 = require("ts-morph");
+var import_ts_morph62 = require("ts-morph");
 var import_resolution6 = require("@suss/resolution");
 var NO_WRAPPERS = {
   wrappersFor: () => [],
@@ -13753,11 +13879,11 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
   const candidates = [];
   const unresolved = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph61.Node.isCallExpression(node)) {
+    if (!import_ts_morph62.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph61.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
+    if (!import_ts_morph62.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -13852,7 +13978,7 @@ function discoverConstructorOptions(sourceFile, pattern, wraps, subjects, resolu
   return { candidates, unresolved };
 }
 function constructorOptionOf(construction, wraps, resolution) {
-  if (!(import_ts_morph61.Node.isNewExpression(construction) || import_ts_morph61.Node.isCallExpression(construction))) {
+  if (!(import_ts_morph62.Node.isNewExpression(construction) || import_ts_morph62.Node.isCallExpression(construction))) {
     return void 0;
   }
   const optionsArg = construction.getArguments()[wraps.targetPosition];
@@ -13882,6 +14008,7 @@ function candidateOf(registration, pattern, sourceFile) {
     reference: {
       file: target.getSourceFile().getFilePath(),
       name: named2 ? functionNameOrAnon(target) : label,
+      ...named2 ? {} : { line: target.getStartLineNumber() },
       ...onThrow ? { onThrow: true } : {},
       ...scope === void 0 ? {} : { scope }
     }
@@ -13890,37 +14017,6 @@ function candidateOf(registration, pattern, sourceFile) {
 function labelFor(targetArg, wraps) {
   return factoryNameOf(targetArg) ?? wraps.method;
 }
-function factoryNameOf(targetArg) {
-  const written = factKeyOf(targetArg);
-  if (!import_ts_morph61.Node.isCallExpression(written)) {
-    return void 0;
-  }
-  const callee = written.getExpression();
-  if (import_ts_morph61.Node.isIdentifier(callee)) {
-    return callee.getText();
-  }
-  if (import_ts_morph61.Node.isPropertyAccessExpression(callee)) {
-    return callee.getName();
-  }
-  return void 0;
-}
-function factoryStopOf(targetArg) {
-  const written = factKeyOf(targetArg);
-  if (!import_ts_morph61.Node.isCallExpression(written)) {
-    return null;
-  }
-  const callee = factoryNameOf(targetArg);
-  if (callee === void 0) {
-    return null;
-  }
-  const reason = classifyStop(
-    declarationsBehind(written.getExpression().getSymbol())
-  );
-  if (!(0, import_behavioral_ir2.worthRecording)(reason)) {
-    return null;
-  }
-  return { callee, reason: "unresolvedWrapper" };
-}
 function mountedAt(subjectId, mountPrefixes, scope) {
   const prefix = mountPrefixes?.prefixForId?.(subjectId) ?? "";
   return (0, import_resolution6.joinMountedPath)(prefix, scope);
@@ -13937,7 +14033,7 @@ function scopeOf(args, wraps, resolution) {
 }
 
 // src/discoveryContext.ts
-var import_ts_morph62 = require("ts-morph");
+var import_ts_morph63 = require("ts-morph");
 function createTsDiscoveryContext(resolution) {
   const store = resolution ?? new ResolutionStore();
   return {
@@ -13972,7 +14068,7 @@ function exportedFunctions(sourceFile, resolution) {
   return out;
 }
 function exportedFunction(decl, resolution) {
-  const writtenAgain = import_ts_morph62.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
+  const writtenAgain = import_ts_morph63.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
   if (!writtenAgain) {
     const declared = resolveDeclarationToFunction(decl);
     if (declared !== null) {
@@ -13993,7 +14089,7 @@ function valueToAskAbout(decl, writtenAgain) {
   if (writtenAgain) {
     return decl;
   }
-  const value = import_ts_morph62.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
+  const value = import_ts_morph63.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
   return couldStillNameAFunction(value) ? value : null;
 }
 function resolveDeclarationToFunction(decl) {
@@ -14001,18 +14097,18 @@ function resolveDeclarationToFunction(decl) {
   if (fn !== null) {
     return fn;
   }
-  if (import_ts_morph62.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph63.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph62.Node.isArrowFunction(init) || import_ts_morph62.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init))) {
       return init;
     }
   }
   return null;
 }
 function hasJsxReturn(func) {
-  if (import_ts_morph62.Node.isArrowFunction(func)) {
+  if (import_ts_morph63.Node.isArrowFunction(func)) {
     const body2 = func.getBody();
-    if (import_ts_morph62.Node.isExpression(body2) && isJsxOrFragment(body2)) {
+    if (import_ts_morph63.Node.isExpression(body2) && isJsxOrFragment(body2)) {
       return true;
     }
   }
@@ -14026,11 +14122,11 @@ function hasJsxReturn(func) {
       traversal.stop();
       return;
     }
-    if (node !== func && (import_ts_morph62.Node.isFunctionDeclaration(node) || import_ts_morph62.Node.isFunctionExpression(node) || import_ts_morph62.Node.isArrowFunction(node) || import_ts_morph62.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph63.Node.isFunctionDeclaration(node) || import_ts_morph63.Node.isFunctionExpression(node) || import_ts_morph63.Node.isArrowFunction(node) || import_ts_morph63.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph62.Node.isReturnStatement(node)) {
+    if (import_ts_morph63.Node.isReturnStatement(node)) {
       const expr = node.getExpression();
       if (expr !== void 0 && isJsxOrFragment(expr)) {
         found = true;
@@ -14041,7 +14137,7 @@ function hasJsxReturn(func) {
 }
 function isJsxOrFragment(node) {
   const current2 = peelParens(node);
-  return import_ts_morph62.Node.isJsxElement(current2) || import_ts_morph62.Node.isJsxSelfClosingElement(current2) || import_ts_morph62.Node.isJsxFragment(current2);
+  return import_ts_morph63.Node.isJsxElement(current2) || import_ts_morph63.Node.isJsxSelfClosingElement(current2) || import_ts_morph63.Node.isJsxFragment(current2);
 }
 
 // src/graphqlContract.ts
@@ -14164,132 +14260,10 @@ function createReferenceIndex(sourceFiles) {
   };
 }
 
-// src/resolve/boundaryEffects.ts
-var import_datalog3 = require("@suss/datalog");
-var EFFECT_RULES = [
-  (0, import_datalog3.rule)(
-    "reachFrom",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("e")],
-    [(0, import_datalog3.lit)("entry", (0, import_datalog3.variable)("e"))]
-  ),
-  (0, import_datalog3.rule)(
-    "reachFrom",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("v")],
-    [
-      (0, import_datalog3.lit)("reachFrom", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("u")),
-      (0, import_datalog3.lit)("calls", (0, import_datalog3.variable)("u"), (0, import_datalog3.variable)("v"))
-    ]
-  ),
-  (0, import_datalog3.rule)(
-    "boundaryEffect",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("kind"), (0, import_datalog3.variable)("target")],
-    [
-      (0, import_datalog3.lit)("reachFrom", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("u")),
-      (0, import_datalog3.lit)("unitEffect", (0, import_datalog3.variable)("u"), (0, import_datalog3.variable)("kind"), (0, import_datalog3.variable)("target"))
-    ]
-  )
-];
-function bindingLabel(binding) {
-  const semantics = binding.semantics;
-  if (semantics.name === "rest") {
-    return `${semantics.method} ${semantics.path}`;
-  }
-  if (semantics.name === "storage") {
-    return `${semantics.storageSystem}:${semantics.container}`;
-  }
-  if (semantics.name === "message-bus") {
-    return `${semantics.messageBus}:${semantics.channel}`;
-  }
-  if (semantics.name === "runtime-config") {
-    return semantics.instanceName;
-  }
-  if (semantics.name === "graphql-resolver") {
-    return `${semantics.typeName}.${semantics.fieldName}`;
-  }
-  if (semantics.name === "graphql-operation") {
-    return `${semantics.operationType} ${semantics.operationName ?? ""}`.trim();
-  }
-  if ("exportName" in semantics || "module" in semantics) {
-    return semantics.exportName ?? semantics.module ?? binding.recognition;
-  }
-  if ("instanceName" in semantics && semantics.instanceName !== null) {
-    return `${semantics.deploymentTarget}:${semantics.instanceName}`;
-  }
-  return binding.recognition;
-}
-function effectFact(effect) {
-  if (effect.type === "invocation") {
-    return { kind: "invocation", target: effect.callee };
-  }
-  if (effect.type === "mutation") {
-    return { kind: "mutation", target: `${effect.operation}:${effect.target}` };
-  }
-  if (effect.type === "emission") {
-    return { kind: "emission", target: effect.event };
-  }
-  if (effect.type === "stateChange") {
-    return { kind: "stateChange", target: effect.variable };
-  }
-  if (effect.type === "interaction") {
-    return { kind: "interaction", target: bindingLabel(effect.binding) };
-  }
-  return null;
-}
-function deriveBoundaryEffects(summaries, facts) {
-  const { db, unitKeyBySummary } = facts;
-  for (const summary of summaries) {
-    const key = unitKeyBySummary.get(summary);
-    if (key === void 0) {
-      continue;
-    }
-    for (const transition of summary.transitions) {
-      for (const effect of transition.effects) {
-        const fact2 = effectFact(effect);
-        if (fact2 !== null) {
-          db.add("unitEffect", [key, fact2.kind, fact2.target]);
-        }
-      }
-    }
-  }
-  (0, import_datalog3.evaluate)(db, EFFECT_RULES);
-  const ownByEntry = /* @__PURE__ */ new Map();
-  for (const [unit, kind, target] of db.facts("unitEffect")) {
-    const bucket = ownByEntry.get(String(unit)) ?? /* @__PURE__ */ new Set();
-    bucket.add(`${kind}\0${target}`);
-    ownByEntry.set(String(unit), bucket);
-  }
-  const closureByEntry = /* @__PURE__ */ new Map();
-  for (const [entry, kind, target] of db.facts("boundaryEffect")) {
-    const entryKey2 = String(entry);
-    const bucket = closureByEntry.get(entryKey2) ?? [];
-    bucket.push({
-      kind: String(kind),
-      target: String(target),
-      transitive: !(ownByEntry.get(entryKey2)?.has(`${kind}\0${target}`) ?? false)
-    });
-    closureByEntry.set(entryKey2, bucket);
-  }
-  for (const summary of summaries) {
-    const key = unitKeyBySummary.get(summary);
-    if (key === void 0 || !db.has("entry", [key])) {
-      continue;
-    }
-    const effects = closureByEntry.get(key);
-    if (effects === void 0 || effects.length === 0) {
-      continue;
-    }
-    const sorted = [...effects].sort(
-      (a, b) => `${a.kind}:${a.target}`.localeCompare(`${b.kind}:${b.target}`)
-    );
-    summary.metadata = { ...summary.metadata, effectsClosure: sorted };
-  }
-  return summaries;
-}
-
 // src/resolve/reachableClosure.ts
-var import_ts_morph63 = require("ts-morph");
+var import_ts_morph64 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
-var import_datalog4 = require("@suss/datalog");
+var import_datalog3 = require("@suss/datalog");
 var import_extractor8 = require("@suss/extractor");
 var GENERIC_TERMINALS = [
   { kind: "return", match: { type: "returnStatement" }, extraction: {} },
@@ -14320,7 +14294,7 @@ function targetOf(node) {
   };
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph63.Node.isCallExpression(call)) {
+  if (!import_ts_morph64.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -14333,7 +14307,7 @@ function resolveCallee(call, calleeName, scan) {
     }
   }
   const resolveSources = scan.resolveCallableSources;
-  if (resolveSources !== void 0 && import_ts_morph63.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+  if (resolveSources !== void 0 && import_ts_morph64.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
     const sources = resolveSources(callee, scan.reachedFrom);
     const only = sources.length === 1 ? sources[0] : void 0;
     const resolved = only === void 0 ? null : resolveDecl(only, calleeName);
@@ -14379,11 +14353,11 @@ function passedPositionKey(target, position) {
   return `${offsetKeyFor(target.file, target.span)}#${position}`;
 }
 function resolveJsxReference(node, scan) {
-  if (!import_ts_morph63.Node.isJsxOpeningElement(node) && !import_ts_morph63.Node.isJsxSelfClosingElement(node)) {
+  if (!import_ts_morph64.Node.isJsxOpeningElement(node) && !import_ts_morph64.Node.isJsxSelfClosingElement(node)) {
     return null;
   }
   const tag = node.getTagNameNode();
-  if (!import_ts_morph63.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
+  if (!import_ts_morph64.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
     return null;
   }
   const name = tag.getText();
@@ -14429,12 +14403,12 @@ function collectReachable(func, scan) {
     candidates.push(outcome.candidate);
   };
   const recordPassedArgs = (call, calleeText, calleeOutcome) => {
-    if (!import_ts_morph63.Node.isCallExpression(call)) {
+    if (!import_ts_morph64.Node.isCallExpression(call)) {
       return;
     }
     const calleeTarget = declaredAtOf(calleeOutcome);
     call.getArguments().forEach((arg, position) => {
-      if (!import_ts_morph63.Node.isIdentifier(arg)) {
+      if (!import_ts_morph64.Node.isIdentifier(arg)) {
         return;
       }
       const resolved = functionTargetOf(arg);
@@ -14454,7 +14428,7 @@ function collectReachable(func, scan) {
       record2(jsx.outcome);
       return;
     }
-    if (!import_ts_morph63.Node.isCallExpression(node)) {
+    if (!import_ts_morph64.Node.isCallExpression(node)) {
       return;
     }
     const calleeText = normalizeCallee(node.getExpression().getText());
@@ -14506,13 +14480,13 @@ function extractReachableSummary(candidate, options, recognizers) {
   return (0, import_extractor8.assembleSummary)(raw, options);
 }
 var REACHABLE_RULES = [
-  (0, import_datalog4.rule)("reachable", [(0, import_datalog4.variable)("f")], [(0, import_datalog4.lit)("entry", (0, import_datalog4.variable)("f"))]),
-  (0, import_datalog4.rule)(
+  (0, import_datalog3.rule)("reachable", [(0, import_datalog3.variable)("f")], [(0, import_datalog3.lit)("entry", (0, import_datalog3.variable)("f"))]),
+  (0, import_datalog3.rule)(
     "reachable",
-    [(0, import_datalog4.variable)("g")],
+    [(0, import_datalog3.variable)("g")],
     [
-      (0, import_datalog4.lit)("reachable", (0, import_datalog4.variable)("f")),
-      (0, import_datalog4.lit)("calls", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("g"))
+      (0, import_datalog3.lit)("reachable", (0, import_datalog3.variable)("f")),
+      (0, import_datalog3.lit)("calls", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("g"))
     ]
   )
 ];
@@ -14540,7 +14514,7 @@ function recognizerOnlyRoots(packsByFile) {
       }
       for (const declaration of variableStatement.getDeclarations()) {
         const init = declaration.getInitializer();
-        if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init)) && hasBody(init)) {
+        if (init !== void 0 && (import_ts_morph64.Node.isArrowFunction(init) || import_ts_morph64.Node.isFunctionExpression(init)) && hasBody(init)) {
           roots.push({ func: init, name: declaration.getName() });
         }
       }
@@ -14550,7 +14524,7 @@ function recognizerOnlyRoots(packsByFile) {
 }
 function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS, alreadySummarized = [], extraRoots = []) {
   const lookup = createSourceFileLookup(project);
-  const db = facts?.db ?? new import_datalog4.Database();
+  const db = facts?.db ?? new import_datalog3.Database();
   const functionByKey = /* @__PURE__ */ new Map();
   const seedKeys = /* @__PURE__ */ new Set();
   const scanned = /* @__PURE__ */ new Set();
@@ -14589,7 +14563,7 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
     }
   }
   for (; ; ) {
-    (0, import_datalog4.evaluate)(db, REACHABLE_RULES);
+    (0, import_datalog3.evaluate)(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
     if (frontier.length === 0) {
       break;
@@ -14794,21 +14768,21 @@ function recordParameterGaps(parameterCallsByKey, summariesByKey, passedPosition
 }
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph64 = require("ts-morph");
-var import_datalog5 = require("@suss/datalog");
+var import_ts_morph65 = require("ts-morph");
+var import_datalog4 = require("@suss/datalog");
 var RETHROW_RULES = [
-  (0, import_datalog5.rule)(
+  (0, import_datalog4.rule)(
     "contributes",
-    [(0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s")],
-    [(0, import_datalog5.lit)("throwsDirect", (0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s"))]
+    [(0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s")],
+    [(0, import_datalog4.lit)("throwsDirect", (0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog4.rule)(
     "contributes",
-    [(0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s")],
+    [(0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s")],
     [
-      (0, import_datalog5.lit)("rethrowSite", (0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("siteCalls", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("contributes", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("s"))
+      (0, import_datalog4.lit)("rethrowSite", (0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("site")),
+      (0, import_datalog4.lit)("siteCalls", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("contributes", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("s"))
     ]
   )
 ];
@@ -14820,7 +14794,7 @@ function enrichRethrows(summaries, project, facts) {
     summary.location.range.start,
     summary.location.range.end
   ));
-  const db = facts?.db ?? new import_datalog5.Database();
+  const db = facts?.db ?? new import_datalog4.Database();
   const sourceById = /* @__PURE__ */ new Map();
   const nameByUnit = /* @__PURE__ */ new Map();
   const targets = [];
@@ -14870,7 +14844,7 @@ function enrichRethrows(summaries, project, facts) {
       }
     }
   }
-  (0, import_datalog5.evaluate)(db, RETHROW_RULES);
+  (0, import_datalog4.evaluate)(db, RETHROW_RULES);
   const contributesByUnit = /* @__PURE__ */ new Map();
   for (const [unit, sourceId] of db.facts("contributes")) {
     const bucket = contributesByUnit.get(String(unit));
@@ -14931,7 +14905,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph64.Node.isThrowStatement(node)) {
+    if (!import_ts_morph65.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -14941,7 +14915,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph64.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph65.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -14951,13 +14925,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph64.Node.isCatchClause(current2)) {
+    if (import_ts_morph65.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph64.Node.isTryStatement(current2)) {
+    if (import_ts_morph65.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph64.Node.isFunctionDeclaration(current2) || import_ts_morph64.Node.isFunctionExpression(current2) || import_ts_morph64.Node.isArrowFunction(current2) || import_ts_morph64.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph65.Node.isFunctionDeclaration(current2) || import_ts_morph65.Node.isFunctionExpression(current2) || import_ts_morph65.Node.isArrowFunction(current2) || import_ts_morph65.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -14965,14 +14939,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph64.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph65.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph64.Node.isCallExpression(node)) {
+    if (!import_ts_morph65.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -14989,7 +14963,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph64.Node.isCallExpression(call)) {
+  if (!import_ts_morph65.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -15019,12 +14993,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph64.Node.isFunctionDeclaration(decl) || import_ts_morph64.Node.isFunctionExpression(decl) || import_ts_morph64.Node.isArrowFunction(decl) || import_ts_morph64.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph65.Node.isFunctionDeclaration(decl) || import_ts_morph65.Node.isFunctionExpression(decl) || import_ts_morph65.Node.isArrowFunction(decl) || import_ts_morph65.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph64.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph65.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph64.Node.isArrowFunction(init) || import_ts_morph64.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph65.Node.isArrowFunction(init) || import_ts_morph65.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -15032,22 +15006,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph65 = require("ts-morph");
+var import_ts_morph66 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph65.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph66.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph65.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph66.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph65.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph66.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph65.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph66.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -15068,11 +15042,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph65.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph66.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph65.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph66.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -15104,7 +15078,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph65.Node.isCallExpression(node)) {
+  if (import_ts_morph66.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -15136,14 +15110,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph65.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph66.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_morph65.Node.isArrowFunction(callback) || import_ts_morph65.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph66.Node.isArrowFunction(callback) || import_ts_morph66.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -15151,11 +15125,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph65.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph66.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap(expr) {
   let node = expr;
-  while (import_ts_morph65.Node.isAwaitExpression(node) || import_ts_morph65.Node.isParenthesizedExpression(node) || import_ts_morph65.Node.isAsExpression(node)) {
+  while (import_ts_morph66.Node.isAwaitExpression(node) || import_ts_morph66.Node.isParenthesizedExpression(node) || import_ts_morph66.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -15165,15 +15139,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph65.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph66.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph65.Node.isExpression(expr) ? unwrap(expr) : expr;
-  if (import_ts_morph65.Node.isCallExpression(node)) {
+  let node = import_ts_morph66.Node.isExpression(expr) ? unwrap(expr) : expr;
+  if (import_ts_morph66.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph65.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph66.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -15192,16 +15166,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph65.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph66.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph66.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph65.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph66.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -15212,7 +15186,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph65.Node.isIdentifier(node)) {
+    if (!import_ts_morph66.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -15224,13 +15198,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph65.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph66.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph66.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -15244,15 +15218,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph65.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph66.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph65.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph66.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph65.Node.isFunctionLikeDeclaration(current2) || import_ts_morph65.Node.isVariableStatement(current2)) {
+    if (import_ts_morph66.Node.isFunctionLikeDeclaration(current2) || import_ts_morph66.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -15315,7 +15289,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph65.Node.isIfStatement(parent)) {
+    if (import_ts_morph66.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -15377,7 +15351,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph66 = require("ts-morph");
+var import_ts_morph67 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -15404,18 +15378,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph66.Node.isJsxOpeningElement(node) && !import_ts_morph66.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph67.Node.isJsxOpeningElement(node) && !import_ts_morph67.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph66.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph67.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph66.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph67.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -15438,11 +15412,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph66.Node.isCallExpression(node)) {
+    if (!import_ts_morph67.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph66.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph67.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -15453,10 +15427,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrowFunction(expr) || import_ts_morph66.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph67.Node.isArrowFunction(expr) || import_ts_morph67.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph66.Node.isIdentifier(expr)) {
+  if (import_ts_morph67.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -15475,15 +15449,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph66.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph67.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph66.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph67.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph66.Node.isArrowFunction(init) || import_ts_morph66.Node.isFunctionExpression(init)) {
+    if (import_ts_morph67.Node.isArrowFunction(init) || import_ts_morph67.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -15504,7 +15478,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrowFunction(arg) || import_ts_morph66.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph67.Node.isArrowFunction(arg) || import_ts_morph67.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -15516,7 +15490,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph67.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -15765,13 +15739,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph67.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph68.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph67.Node.isOmittedExpression(element)) {
+      if (import_ts_morph68.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -15801,7 +15775,7 @@ function objectParamInputs(param, position, mapping) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -15831,7 +15805,7 @@ function bindingRole(element, name) {
   if (property === void 0) {
     return name;
   }
-  if (import_ts_morph67.Node.isStringLiteral(property)) {
+  if (import_ts_morph68.Node.isStringLiteral(property)) {
     return property.getLiteralValue();
   }
   return property.getText();
@@ -15863,7 +15837,7 @@ function extractParameters(func, inputMapping) {
       const param = params[i];
       const nameNode = param.getNameNode();
       const boundNames = bindingPatternNames(nameNode);
-      if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+      if (import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
         for (const element of nameNode.getElements()) {
           result.push({
             name: element.getName(),
@@ -15930,7 +15904,7 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph67.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph68.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -15939,19 +15913,19 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph67.Node.isAwaitExpression(init)) {
+    if (import_ts_morph68.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph67.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph68.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph67.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph68.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph67.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph68.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -16310,6 +16284,10 @@ function extractBindingPath(binding, callSite, pack, resolution) {
     const arg = callSite.callExpression.getArguments()[p.position];
     return arg === void 0 ? void 0 : pathFromArgument(arg, resolution);
   }
+  if (p.type === "fromArgumentProperty") {
+    const arg = callSite.callExpression.getArguments()[p.position];
+    return arg === void 0 ? void 0 : pathFromProperty(arg, p.property, resolution);
+  }
   return void 0;
 }
 function resolveContractField(callSite, pack, field, resolution) {
@@ -16705,20 +16683,23 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
   return summaries;
 }
 function stampWrappers(raw, unit, wrappers) {
-  if (wrappers === void 0 || unit.registrationSubjectId === void 0) {
-    return;
-  }
-  const applied = wrappers.wrappersFor(unit.registrationSubjectId);
+  const applied = [
+    ...wrappers === void 0 || unit.registrationSubjectId === void 0 ? [] : wrappers.wrappersFor(unit.registrationSubjectId),
+    ...unit.routeWrappers ?? []
+  ];
   if (applied.length === 0) {
     return;
   }
-  raw.wrappers = [...applied];
+  raw.wrappers = applied;
   for (const wrapper of applied) {
     recordFileDependency(wrapper.file);
   }
 }
 function unfollowedStopsOf(unit, wrappers) {
-  const stops = unit.unfollowed === void 0 ? [] : [unit.unfollowed];
+  const stops = [
+    ...unit.unfollowed === void 0 ? [] : [unit.unfollowed],
+    ...unit.routeUnfollowed ?? []
+  ];
   if (wrappers === void 0 || unit.registrationSubjectId === void 0) {
     return stops;
   }
@@ -16865,9 +16846,9 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(import_ts_morph67.SyntaxKind.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(import_ts_morph68.SyntaxKind.CallExpression)) {
     const first = call.getArguments()[0];
-    if (first === void 0 || !import_ts_morph67.Node.isIdentifier(first)) {
+    if (first === void 0 || !import_ts_morph68.Node.isIdentifier(first)) {
       continue;
     }
     const at = names.indexOf(first.getText());
@@ -16916,16 +16897,16 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph68.Node.isFunctionDeclaration(func) || import_ts_morph68.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph67.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph68.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph68.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph68.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -16934,10 +16915,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph67.Node.isCallExpression(current2)) {
+    if (import_ts_morph68.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph67.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph68.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -16948,7 +16929,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph67.Node.isFunctionDeclaration(current2) || import_ts_morph67.Node.isFunctionExpression(current2) || import_ts_morph67.Node.isArrowFunction(current2) || import_ts_morph67.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph68.Node.isFunctionDeclaration(current2) || import_ts_morph68.Node.isFunctionExpression(current2) || import_ts_morph68.Node.isArrowFunction(current2) || import_ts_morph68.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -16956,13 +16937,13 @@ function enclosingFunction(node) {
   return null;
 }
 function callerName(func) {
-  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph68.Node.isFunctionDeclaration(func) || import_ts_morph68.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph68.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph68.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -17061,7 +17042,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? import_node_path11.default.dirname(suppliedConfig.tsConfigFilePath) : void 0)
     )
   };
-  const project = config.project ?? new import_ts_morph67.Project(
+  const project = config.project ?? new import_ts_morph68.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -17108,7 +17089,11 @@ function createTypeScriptAdapter(suppliedConfig) {
           )
         );
       }
-      return named(summaries, config.workspace, runRoot);
+      return named(
+        (0, import_extractor12.composeWrappers)(summaries, config.extractorOptions ?? {}),
+        config.workspace,
+        runRoot
+      );
     },
     async extractAll() {
       const timer = (0, import_extractor9.createTimer)();
@@ -17319,7 +17304,7 @@ function createTypeScriptAdapter(suppliedConfig) {
         )
       );
       const closureFacts = {
-        db: new import_datalog6.Database(),
+        db: new import_datalog5.Database(),
         unitKeyBySummary: /* @__PURE__ */ new Map(),
         ...caching ? { filesByKey: /* @__PURE__ */ new Map() } : {}
       };
@@ -17368,12 +17353,6 @@ function createTypeScriptAdapter(suppliedConfig) {
         "enrichRethrows",
         () => enrichRethrows(merged.summaries, project, closureFacts)
       );
-      if (config.includeReachable !== false) {
-        timer.time(
-          "deriveBoundaryEffects",
-          () => deriveBoundaryEffects(enriched, closureFacts)
-        );
-      }
       timer.time(
         "stampModuleImports",
         () => (0, import_extractor12.stampModuleImports)(enriched, (file) => {
@@ -17777,7 +17756,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path12 = __toESM(require("path"), 1);
-var import_ts_morph68 = require("ts-morph");
+var import_ts_morph69 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -17825,12 +17804,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph68.Project({
+  const project = new import_ts_morph69.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph68.ScriptTarget.ES2022,
-      module: import_ts_morph68.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph68.ModuleResolutionKind.Bundler,
+      target: import_ts_morph69.ScriptTarget.ES2022,
+      module: import_ts_morph69.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph69.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -17852,10 +17831,18 @@ function createProjectWithoutTsconfig(rootDir) {
   }
   return { project, files };
 }
+var TSCONFIG_NAMES = [
+  "tsconfig.json",
+  "jsconfig.json",
+  "tsconfig.base.json"
+];
+var WALK_UP_TSCONFIG_NAMES = ["tsconfig.json", "jsconfig.json"];
 function findNearestTsconfig(startDir) {
-  let dir = import_node_path12.default.resolve(startDir);
+  const start = import_node_path12.default.resolve(startDir);
+  let dir = start;
   while (true) {
-    for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const names = dir === start ? TSCONFIG_NAMES : WALK_UP_TSCONFIG_NAMES;
+    for (const name of names) {
       const candidate = import_node_path12.default.join(dir, name);
       if (import_node_fs5.default.existsSync(candidate)) {
         return candidate;
@@ -17871,7 +17858,7 @@ function findNearestTsconfig(startDir) {
 
 // src/facts/why.ts
 var import_node_path13 = __toESM(require("path"), 1);
-var import_ts_morph69 = require("ts-morph");
+var import_ts_morph70 = require("ts-morph");
 var import_resolution7 = require("@suss/resolution");
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -17885,7 +17872,7 @@ var TypeScriptWhySession = class {
   constructor(options) {
     this.root = import_node_path13.default.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
-    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph69.Project({ tsConfigFilePath: tsconfig });
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph70.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
   }
   /**
@@ -17900,7 +17887,7 @@ var TypeScriptWhySession = class {
     }
     let found = null;
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph69.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+      if (import_ts_morph70.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
         found = node;
       }
     });
@@ -17918,7 +17905,7 @@ var TypeScriptWhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      import_ts_morph69.SyntaxKind.CallExpression
+      import_ts_morph70.SyntaxKind.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -17992,21 +17979,21 @@ var TypeScriptWhySession = class {
   }
 };
 function displayNameOf(node) {
-  if (import_ts_morph69.Node.isIdentifier(node) || import_ts_morph69.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph70.Node.isIdentifier(node) || import_ts_morph70.Node.isPropertyAccessExpression(node)) {
     return node.getText();
   }
-  if (import_ts_morph69.Node.isCallExpression(node) || import_ts_morph69.Node.isNewExpression(node)) {
+  if (import_ts_morph70.Node.isCallExpression(node) || import_ts_morph70.Node.isNewExpression(node)) {
     return `${node.getExpression()?.getText() ?? "call"}(...)`;
   }
-  if (import_ts_morph69.Node.isFunctionDeclaration(node) || import_ts_morph69.Node.isClassDeclaration(node) || import_ts_morph69.Node.isMethodDeclaration(node) || import_ts_morph69.Node.isVariableDeclaration(node)) {
+  if (import_ts_morph70.Node.isFunctionDeclaration(node) || import_ts_morph70.Node.isClassDeclaration(node) || import_ts_morph70.Node.isMethodDeclaration(node) || import_ts_morph70.Node.isVariableDeclaration(node)) {
     const name = node.getName();
     if (name !== void 0) {
       return name;
     }
   }
-  if (import_ts_morph69.Node.isArrowFunction(node) || import_ts_morph69.Node.isFunctionExpression(node)) {
+  if (import_ts_morph70.Node.isArrowFunction(node) || import_ts_morph70.Node.isFunctionExpression(node)) {
     const parent = node.getParent();
-    if (parent !== void 0 && import_ts_morph69.Node.isVariableDeclaration(parent)) {
+    if (parent !== void 0 && import_ts_morph70.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
   }
@@ -18016,7 +18003,7 @@ function displayNameOf(node) {
 
 // src/stubEvidence.ts
 var import_node_path14 = __toESM(require("path"), 1);
-var import_ts_morph70 = require("ts-morph");
+var import_ts_morph71 = require("ts-morph");
 function stubEvidenceIn(project, packageName, root) {
   const resolution = new ResolutionStore();
   const byExport = /* @__PURE__ */ new Map();
@@ -18043,7 +18030,7 @@ function stubEvidenceIn(project, packageName, root) {
   );
 }
 function stubEvidence(options) {
-  const project = new import_ts_morph70.Project(
+  const project = new import_ts_morph71.Project(
     options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : { compilerOptions: { allowJs: true } }
   );
   const root = options.tsConfigFilePath !== void 0 ? import_node_path14.default.dirname(options.tsConfigFilePath) : import_node_path14.default.resolve(options.directory ?? process.cwd());
@@ -18061,6 +18048,7 @@ function stubEvidence(options) {
   GENERIC_TERMINALS,
   NO_BARRIERS,
   ResolutionStore,
+  TSCONFIG_NAMES,
   TypeScriptWhySession,
   accessContextFor,
   buildProjectHelperIndex,