@suss/adapter-typescript 0.17.0 → 0.18.0

package/dist/index.cjs

@@ -68,13 +68,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path10 = __toESM(require("path"), 1);
-var import_ts_morph60 = require("ts-morph");
+var import_ts_morph61 = require("ts-morph");
 var import_behavioral_ir8 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor5 = require("@suss/extractor");
 
 // src/assembly.ts
-var import_ts_morph26 = require("ts-morph");
+var import_ts_morph27 = require("ts-morph");
 
 // src/conditions.ts
 var import_ts_morph6 = require("ts-morph");
@@ -3450,19 +3450,117 @@ function unwrapCall(node) {
 }
 
 // src/terminals/index.ts
-var import_ts_morph25 = require("ts-morph");
+var import_ts_morph26 = require("ts-morph");
 
 // src/terminals/jsx.ts
+var import_ts_morph17 = require("ts-morph");
+
+// src/resolve/unfollowedCall.ts
 var import_ts_morph16 = require("ts-morph");
+function isInExternalCode(sourceFile) {
+  if (sourceFile.isDeclarationFile()) {
+    return true;
+  }
+  return sourceFile.getFilePath().includes("/node_modules/");
+}
+function hasBody(fn) {
+  if (import_ts_morph16.Node.isFunctionDeclaration(fn) || import_ts_morph16.Node.isMethodDeclaration(fn) || import_ts_morph16.Node.isFunctionExpression(fn)) {
+    return fn.getBody?.() !== void 0;
+  }
+  return true;
+}
+function isDeclaredShape(declaration) {
+  return (import_ts_morph16.Node.isMethodSignature(declaration) || import_ts_morph16.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+}
+function isExternalDeclaration(declaration) {
+  if (isInExternalCode(declaration.getSourceFile())) {
+    return true;
+  }
+  if (import_ts_morph16.Node.isImportSpecifier(declaration) || import_ts_morph16.Node.isImportClause(declaration) || import_ts_morph16.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph16.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    return target === void 0 || isInExternalCode(target);
+  }
+  return declaresAnotherModule(declaration);
+}
+function declaresAnotherModule(declaration) {
+  const module2 = declaration.getFirstAncestorByKind(
+    import_ts_morph16.SyntaxKind.ModuleDeclaration
+  );
+  return module2 !== void 0 && import_ts_morph16.Node.isStringLiteral(module2.getNameNode());
+}
+function statesShapeOnly(declaration) {
+  if (isExternalDeclaration(declaration)) {
+    return false;
+  }
+  if (import_ts_morph16.Node.isMethodSignature(declaration) || import_ts_morph16.Node.isPropertySignature(declaration)) {
+    return true;
+  }
+  if (import_ts_morph16.Node.isFunctionDeclaration(declaration) || import_ts_morph16.Node.isMethodDeclaration(declaration)) {
+    return declaration.getBody() === void 0;
+  }
+  return false;
+}
+function declarationsBehind(symbol) {
+  if (symbol === void 0) {
+    return [];
+  }
+  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
+  return behind.length > 0 ? behind : symbol.getDeclarations();
+}
+function classifyStop(declarations) {
+  if (declarations.length === 0) {
+    return "noDeclaration";
+  }
+  for (const declaration of declarations) {
+    if (!isInExternalCode(declaration.getSourceFile())) {
+      recordFileDependency(declaration.getSourceFile().getFilePath());
+    }
+  }
+  if (declarations.every(isExternalDeclaration)) {
+    return "outsideRun";
+  }
+  if (declarations.some(statesShapeOnly)) {
+    return "noBody";
+  }
+  return "unsettledValue";
+}
+var RECORDED = {
+  noBody: true,
+  unsettledValue: true,
+  multipleSources: true,
+  outsideRun: false,
+  noDeclaration: false
+};
+function worthRecording(reason) {
+  return RECORDED[reason];
+}
+var STOP_SENTENCE = {
+  noBody: (callee) => `The call to ${callee} lands on a declaration with no body, so whatever runs there is missing from this summary`,
+  unsettledValue: (callee) => `The call to ${callee} goes through a value this run could not settle, so whatever runs there is missing from this summary`,
+  multipleSources: (callee) => `The call to ${callee} reaches a value with more than one possible source, so whatever runs there is missing from this summary`,
+  outsideRun: (callee) => `The call to ${callee} lands in a package whose source is not in this run, so whatever runs there is missing from this summary`,
+  noDeclaration: (callee) => `The call to ${callee} has no declaration this run could find, so whatever runs there is missing from this summary`
+};
+function unfollowedCallGap(stop) {
+  return {
+    type: "unfollowedCall",
+    conditions: [],
+    consequence: "unknown",
+    description: STOP_SENTENCE[stop.reason](stop.callee),
+    callee: stop.callee
+  };
+}
+
+// src/terminals/jsx.ts
 function tryMatchJsxReturn(node, pattern) {
   let expr;
   let source;
-  if (import_ts_morph16.Node.isReturnStatement(node)) {
+  if (import_ts_morph17.Node.isReturnStatement(node)) {
     expr = node.getExpression();
     source = node;
-  } else if (import_ts_morph16.Node.isArrowFunction(node)) {
+  } else if (import_ts_morph17.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph16.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph17.Node.isBlock(body)) {
       expr = body;
       source = body;
     }
@@ -3492,34 +3590,62 @@ function tryMatchJsxReturn(node, pattern) {
   };
   return { node, source, terminal };
 }
+function componentTargetOf(tagNode) {
+  if (!import_ts_morph17.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+    return null;
+  }
+  for (const decl of declarationsBehind(tagNode.getSymbol())) {
+    if (isInExternalCode(decl.getSourceFile())) {
+      continue;
+    }
+    const name = import_ts_morph17.Node.isFunctionDeclaration(decl) ? decl.getName() : void 0;
+    if (name !== void 0) {
+      return { file: decl.getSourceFile().getFilePath(), name };
+    }
+    if (import_ts_morph17.Node.isVariableDeclaration(decl)) {
+      const init = decl.getInitializer();
+      if (init !== void 0 && (import_ts_morph17.Node.isArrowFunction(init) || import_ts_morph17.Node.isFunctionExpression(init))) {
+        return {
+          file: decl.getSourceFile().getFilePath(),
+          name: decl.getName()
+        };
+      }
+    }
+  }
+  return null;
+}
 function jsxToRenderNode(node) {
-  if (import_ts_morph16.Node.isJsxElement(node)) {
+  if (import_ts_morph17.Node.isJsxElement(node)) {
     const opening = node.getOpeningElement();
     const tag = opening.getTagNameNode().getText();
     const attrs = collectJsxAttributes(opening);
+    const target = componentTargetOf(opening.getTagNameNode());
     const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
     return {
       type: "element",
       tag,
       children,
-      ...attrs !== null ? { attrs } : {}
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph16.Node.isJsxSelfClosingElement(node)) {
+  if (import_ts_morph17.Node.isJsxSelfClosingElement(node)) {
     const tag = node.getTagNameNode().getText();
     const attrs = collectJsxAttributes(node);
+    const target = componentTargetOf(node.getTagNameNode());
     return {
       type: "element",
       tag,
       children: [],
-      ...attrs !== null ? { attrs } : {}
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph16.Node.isJsxFragment(node)) {
+  if (import_ts_morph17.Node.isJsxFragment(node)) {
     const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
     return { type: "element", tag: "Fragment", children };
   }
-  if (import_ts_morph16.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph17.Node.isParenthesizedExpression(node)) {
     return jsxToRenderNode(node.getExpression());
   }
   return null;
@@ -3527,12 +3653,12 @@ function jsxToRenderNode(node) {
 function collectJsxAttributes(opening) {
   const entries = {};
   for (const attr of opening.getAttributes()) {
-    if (import_ts_morph16.Node.isJsxSpreadAttribute(attr)) {
+    if (import_ts_morph17.Node.isJsxSpreadAttribute(attr)) {
       const exprText = attr.getExpression().getText();
       entries[`...${exprText}`] = exprText;
       continue;
     }
-    if (!import_ts_morph16.Node.isJsxAttribute(attr)) {
+    if (!import_ts_morph17.Node.isJsxAttribute(attr)) {
       continue;
     }
     const name = attr.getNameNode().getText();
@@ -3541,7 +3667,7 @@ function collectJsxAttributes(opening) {
       entries[name] = "";
       continue;
     }
-    if (import_ts_morph16.Node.isJsxExpression(initializer)) {
+    if (import_ts_morph17.Node.isJsxExpression(initializer)) {
       const inner = initializer.getExpression();
       entries[name] = inner !== void 0 ? inner.getText() : "";
       continue;
@@ -3551,30 +3677,30 @@ function collectJsxAttributes(opening) {
   return Object.keys(entries).length > 0 ? entries : null;
 }
 function jsxChildToRenderNode(child) {
-  if (import_ts_morph16.Node.isJsxText(child)) {
+  if (import_ts_morph17.Node.isJsxText(child)) {
     const text = child.getLiteralText().trim();
     if (text.length === 0) {
       return null;
     }
     return { type: "text", value: text };
   }
-  if (import_ts_morph16.Node.isJsxExpression(child)) {
+  if (import_ts_morph17.Node.isJsxExpression(child)) {
     const inner = child.getExpression();
     if (inner === void 0) {
       return null;
     }
     return jsxExpressionToRenderNode(inner);
   }
-  if (import_ts_morph16.Node.isJsxElement(child) || import_ts_morph16.Node.isJsxSelfClosingElement(child) || import_ts_morph16.Node.isJsxFragment(child)) {
+  if (import_ts_morph17.Node.isJsxElement(child) || import_ts_morph17.Node.isJsxSelfClosingElement(child) || import_ts_morph17.Node.isJsxFragment(child)) {
     return jsxToRenderNode(child);
   }
   return null;
 }
 function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph16.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph17.Node.isParenthesizedExpression(expr)) {
     return jsxExpressionToRenderNode(expr.getExpression());
   }
-  if (import_ts_morph16.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph17.Node.isBinaryExpression(expr)) {
     const op = expr.getOperatorToken().getText();
     if (op === "&&") {
       const right = renderAlternative(peelParens(expr.getRight()));
@@ -3588,7 +3714,7 @@ function jsxExpressionToRenderNode(expr) {
       }
     }
   }
-  if (import_ts_morph16.Node.isConditionalExpression(expr)) {
+  if (import_ts_morph17.Node.isConditionalExpression(expr)) {
     const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
     const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
     if (truthy.kind === "jsx") {
@@ -3611,16 +3737,16 @@ function jsxExpressionToRenderNode(expr) {
   return { type: "expression", sourceText: expr.getText() };
 }
 function renderAlternative(node) {
-  if (import_ts_morph16.Node.isNullLiteral(node)) {
+  if (import_ts_morph17.Node.isNullLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph16.Node.isFalseLiteral(node)) {
+  if (import_ts_morph17.Node.isFalseLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph16.Node.isIdentifier(node) && node.getText() === "undefined") {
+  if (import_ts_morph17.Node.isIdentifier(node) && node.getText() === "undefined") {
     return { kind: "noRender" };
   }
-  if (import_ts_morph16.Node.isJsxElement(node) || import_ts_morph16.Node.isJsxSelfClosingElement(node) || import_ts_morph16.Node.isJsxFragment(node)) {
+  if (import_ts_morph17.Node.isJsxElement(node) || import_ts_morph17.Node.isJsxSelfClosingElement(node) || import_ts_morph17.Node.isJsxFragment(node)) {
     const tree = jsxToRenderNode(node);
     if (tree !== null) {
       return { kind: "jsx", node: tree };
@@ -3630,10 +3756,10 @@ function renderAlternative(node) {
 }
 
 // src/terminals/returns.ts
-var import_ts_morph23 = require("ts-morph");
+var import_ts_morph24 = require("ts-morph");
 
 // src/shapes/shapes.ts
-var import_ts_morph17 = require("ts-morph");
+var import_ts_morph18 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
@@ -4092,60 +4218,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph17.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph18.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph17.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph18.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph17.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph18.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph17.Node.isStringLiteral(unwrapped2) || import_ts_morph17.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph18.Node.isStringLiteral(unwrapped2) || import_ts_morph18.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph17.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph18.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph17.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph18.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph17.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph18.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph17.SyntaxKind.MinusToken || op === import_ts_morph17.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph18.SyntaxKind.MinusToken || op === import_ts_morph18.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph17.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph18.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph17.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph18.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph17.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph18.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph17.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph18.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph17.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph18.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph17.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph18.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph17.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph18.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph17.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph18.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph17.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph18.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -4176,7 +4302,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph17.Node.isSpreadElement(el)) {
+    if (import_ts_morph18.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -4195,7 +4321,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph17.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph18.Node.isPropertyAssignment(prop)) {
       const name = propertyName(prop);
       if (name === null) {
         continue;
@@ -4211,7 +4337,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph17.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph18.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -4220,7 +4346,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph17.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph18.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -4239,7 +4365,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName(prop) {
   const nameNode = prop.getNameNode();
-  if (import_ts_morph17.Node.isIdentifier(nameNode) || import_ts_morph17.Node.isStringLiteral(nameNode) || import_ts_morph17.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph17.Node.isNumericLiteral(nameNode)) {
+  if (import_ts_morph18.Node.isIdentifier(nameNode) || import_ts_morph18.Node.isStringLiteral(nameNode) || import_ts_morph18.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph18.Node.isNumericLiteral(nameNode)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -4265,21 +4391,21 @@ function collapseVariants2(shapes) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph18 = require("ts-morph");
+var import_ts_morph19 = require("ts-morph");
 function unwrapAs(node) {
-  return import_ts_morph18.Node.isAsExpression(node) ? unwrapAs(node.getExpression()) : node;
+  return import_ts_morph19.Node.isAsExpression(node) ? unwrapAs(node.getExpression()) : node;
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph18.Node.isCallExpression(outer)) {
+  if (!import_ts_morph19.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph18.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph19.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph18.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph19.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -4289,7 +4415,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph18.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph19.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -4323,11 +4449,11 @@ function matchConstructorCode(ctorText, codes) {
 }
 function statusOf(value, ctx) {
   const unwrapped2 = unwrapAs(value);
-  if (import_ts_morph18.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph19.Node.isNumericLiteral(unwrapped2)) {
     return { type: "literal", value: Number(unwrapped2.getText()) };
   }
   const resolved = ctx.resolveWrittenValue?.(unwrapped2) ?? null;
-  if (resolved !== null && import_ts_morph18.Node.isNumericLiteral(resolved)) {
+  if (resolved !== null && import_ts_morph19.Node.isNumericLiteral(resolved)) {
     return { type: "literal", value: Number(resolved.getText()) };
   }
   return { type: "dynamic", sourceText: unwrapped2.getText() };
@@ -4337,10 +4463,10 @@ function statusFromProperty(obj, name, ctx) {
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph18.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph19.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph18.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph19.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -4363,7 +4489,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph18.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph19.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -4376,7 +4502,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph18.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph19.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -4385,7 +4511,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_morph18.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph19.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -4395,8 +4521,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph18.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph18.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph19.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph19.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -4454,8 +4580,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph18.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph18.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph19.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph19.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -4510,10 +4636,10 @@ function extractBody(ctx) {
 }
 
 // src/terminals/helperResolution.ts
-var import_ts_morph19 = require("ts-morph");
+var import_ts_morph20 = require("ts-morph");
 function resolveHelperReturn(call) {
   const callee = call.getExpression();
-  if (!import_ts_morph19.Node.isIdentifier(callee)) {
+  if (!import_ts_morph20.Node.isIdentifier(callee)) {
     return { kind: "notLocal" };
   }
   const helper = resolveLocalHelper(callee);
@@ -4543,16 +4669,16 @@ function guardsAbove(returnValue) {
   let child = returnValue;
   let current2 = returnValue.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph19.Node.isIfStatement(current2)) {
+    if (import_ts_morph20.Node.isIfStatement(current2)) {
       guards.push({
         condition: current2.getExpression(),
         whenTrue: current2.getThenStatement() === child
       });
     }
-    if (import_ts_morph19.Node.isBlock(current2)) {
+    if (import_ts_morph20.Node.isBlock(current2)) {
       guards.push(...earlyReturnGuardsBefore(current2, child));
     }
-    if (import_ts_morph19.Node.isFunctionDeclaration(current2) || import_ts_morph19.Node.isArrowFunction(current2) || import_ts_morph19.Node.isFunctionExpression(current2)) {
+    if (import_ts_morph20.Node.isFunctionDeclaration(current2) || import_ts_morph20.Node.isArrowFunction(current2) || import_ts_morph20.Node.isFunctionExpression(current2)) {
       break;
     }
     child = current2;
@@ -4561,7 +4687,7 @@ function guardsAbove(returnValue) {
   return guards;
 }
 function earlyReturnGuardsBefore(block, child) {
-  if (!import_ts_morph19.Node.isBlock(block)) {
+  if (!import_ts_morph20.Node.isBlock(block)) {
     return [];
   }
   const guards = [];
@@ -4569,7 +4695,7 @@ function earlyReturnGuardsBefore(block, child) {
     if (statement === child) {
       break;
     }
-    if (!import_ts_morph19.Node.isIfStatement(statement) || statement.getElseStatement()) {
+    if (!import_ts_morph20.Node.isIfStatement(statement) || statement.getElseStatement()) {
       continue;
     }
     if (alwaysReturns(statement.getThenStatement())) {
@@ -4579,10 +4705,10 @@ function earlyReturnGuardsBefore(block, child) {
   return guards;
 }
 function alwaysReturns(statement) {
-  if (import_ts_morph19.Node.isReturnStatement(statement) || import_ts_morph19.Node.isThrowStatement(statement)) {
+  if (import_ts_morph20.Node.isReturnStatement(statement) || import_ts_morph20.Node.isThrowStatement(statement)) {
     return true;
   }
-  if (!import_ts_morph19.Node.isBlock(statement)) {
+  if (!import_ts_morph20.Node.isBlock(statement)) {
     return false;
   }
   const statements = statement.getStatements();
@@ -4600,7 +4726,7 @@ var COMPARISONS = {
   "!=": (a, b) => a !== b
 };
 function evaluateComparison(condition, substitutions) {
-  if (!import_ts_morph19.Node.isBinaryExpression(condition)) {
+  if (!import_ts_morph20.Node.isBinaryExpression(condition)) {
     return null;
   }
   const left = numberFor(condition.getLeft(), substitutions);
@@ -4612,8 +4738,8 @@ function evaluateComparison(condition, substitutions) {
   return compare === void 0 ? null : compare(left, right);
 }
 function numberFor(node, substitutions) {
-  const resolved = import_ts_morph19.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
-  return import_ts_morph19.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
+  const resolved = import_ts_morph20.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
+  return import_ts_morph20.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
 }
 function resolveLocalHelper(callee) {
   for (const declaration of declarationsFor(callee)) {
@@ -4682,12 +4808,12 @@ function declarationsFor(callee) {
   return (aliased ?? symbol).getDeclarations();
 }
 function asFunctionLike(declaration) {
-  if (import_ts_morph19.Node.isFunctionDeclaration(declaration) || import_ts_morph19.Node.isArrowFunction(declaration) || import_ts_morph19.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph20.Node.isFunctionDeclaration(declaration) || import_ts_morph20.Node.isArrowFunction(declaration) || import_ts_morph20.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (import_ts_morph19.Node.isVariableDeclaration(declaration)) {
+  if (import_ts_morph20.Node.isVariableDeclaration(declaration)) {
     const initializer = declaration.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph19.Node.isArrowFunction(initializer) || import_ts_morph19.Node.isFunctionExpression(initializer))) {
+    if (initializer !== void 0 && (import_ts_morph20.Node.isArrowFunction(initializer) || import_ts_morph20.Node.isFunctionExpression(initializer))) {
       return initializer;
     }
   }
@@ -4698,13 +4824,13 @@ function returnedObjects(fn) {
   if (body === void 0) {
     return [];
   }
-  if (!import_ts_morph19.Node.isBlock(body)) {
+  if (!import_ts_morph20.Node.isBlock(body)) {
     const expression = peelParens(body);
-    return import_ts_morph19.Node.isObjectLiteralExpression(expression) ? [expression] : [];
+    return import_ts_morph20.Node.isObjectLiteralExpression(expression) ? [expression] : [];
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    import_ts_morph19.SyntaxKind.ReturnStatement
+    import_ts_morph20.SyntaxKind.ReturnStatement
   )) {
     if (enclosingFunctionOf(statement) !== body) {
       continue;
@@ -4714,7 +4840,7 @@ function returnedObjects(fn) {
       continue;
     }
     const unwrapped2 = peelParens(expression);
-    if (import_ts_morph19.Node.isObjectLiteralExpression(unwrapped2)) {
+    if (import_ts_morph20.Node.isObjectLiteralExpression(unwrapped2)) {
       found.push(unwrapped2);
     }
   }
@@ -4723,7 +4849,7 @@ function returnedObjects(fn) {
 function enclosingFunctionOf(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph19.Node.isFunctionDeclaration(current2) || import_ts_morph19.Node.isArrowFunction(current2) || import_ts_morph19.Node.isFunctionExpression(current2) || import_ts_morph19.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph20.Node.isFunctionDeclaration(current2) || import_ts_morph20.Node.isArrowFunction(current2) || import_ts_morph20.Node.isFunctionExpression(current2) || import_ts_morph20.Node.isMethodDeclaration(current2)) {
       return current2.getBody();
     }
     current2 = current2.getParent();
@@ -4742,10 +4868,10 @@ function bindArguments(callArgs, params) {
 }
 
 // src/terminals/shared.ts
-var import_ts_morph20 = require("ts-morph");
+var import_ts_morph21 = require("ts-morph");
 function unwrapValue(node) {
   let current2 = node;
-  while (import_ts_morph20.Node.isParenthesizedExpression(current2) || import_ts_morph20.Node.isAwaitExpression(current2) || import_ts_morph20.Node.isAsExpression(current2) || import_ts_morph20.Node.isNonNullExpression(current2) || import_ts_morph20.Node.isSatisfiesExpression(current2)) {
+  while (import_ts_morph21.Node.isParenthesizedExpression(current2) || import_ts_morph21.Node.isAwaitExpression(current2) || import_ts_morph21.Node.isAsExpression(current2) || import_ts_morph21.Node.isNonNullExpression(current2) || import_ts_morph21.Node.isSatisfiesExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
@@ -4757,17 +4883,17 @@ function returnPositionOf(value) {
     if (parent === void 0) {
       return null;
     }
-    if (import_ts_morph20.Node.isReturnStatement(parent)) {
+    if (import_ts_morph21.Node.isReturnStatement(parent)) {
       return parent;
     }
-    if (import_ts_morph20.Node.isArrowFunction(parent)) {
+    if (import_ts_morph21.Node.isArrowFunction(parent)) {
       return parent.getBody() === current2 ? current2 : null;
     }
-    if (import_ts_morph20.Node.isParenthesizedExpression(parent) || import_ts_morph20.Node.isAwaitExpression(parent) || import_ts_morph20.Node.isAsExpression(parent) || import_ts_morph20.Node.isNonNullExpression(parent) || import_ts_morph20.Node.isSatisfiesExpression(parent)) {
+    if (import_ts_morph21.Node.isParenthesizedExpression(parent) || import_ts_morph21.Node.isAwaitExpression(parent) || import_ts_morph21.Node.isAsExpression(parent) || import_ts_morph21.Node.isNonNullExpression(parent) || import_ts_morph21.Node.isSatisfiesExpression(parent)) {
       current2 = parent;
       continue;
     }
-    if (import_ts_morph20.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
+    if (import_ts_morph21.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
       current2 = parent;
       continue;
     }
@@ -4776,10 +4902,10 @@ function returnPositionOf(value) {
 }
 
 // src/terminals/statusBranches.ts
-var import_ts_morph22 = require("ts-morph");
+var import_ts_morph23 = require("ts-morph");
 
 // src/facts/assignments.ts
-var import_ts_morph21 = require("ts-morph");
+var import_ts_morph22 = require("ts-morph");
 var byFile = createPerFileCache();
 var byDeclaration = /* @__PURE__ */ new WeakMap();
 var byField = /* @__PURE__ */ new WeakMap();
@@ -4844,7 +4970,7 @@ function writesToFieldUncached(declaration) {
   };
 }
 function startingValueOf(declaration) {
-  return import_ts_morph21.Node.isParameterDeclaration(declaration) ? declaration : declaration.getInitializer();
+  return import_ts_morph22.Node.isParameterDeclaration(declaration) ? declaration : declaration.getInitializer();
 }
 function writeRunsInConstructor(declaration, write) {
   const statement = statementOf(write.node);
@@ -4852,24 +4978,24 @@ function writeRunsInConstructor(declaration, write) {
     return false;
   }
   const body = statement.getParent();
-  if (body === void 0 || !import_ts_morph21.Node.isBlock(body)) {
+  if (body === void 0 || !import_ts_morph22.Node.isBlock(body)) {
     return false;
   }
   const owner = body.getParent();
-  return owner !== void 0 && import_ts_morph21.Node.isConstructorDeclaration(owner) && owner.getParent() === classHolding(declaration);
+  return owner !== void 0 && import_ts_morph22.Node.isConstructorDeclaration(owner) && owner.getParent() === classHolding(declaration);
 }
 function classHolding(declaration) {
-  return import_ts_morph21.Node.isParameterDeclaration(declaration) ? declaration.getParent().getParent() : declaration.getParent();
+  return import_ts_morph22.Node.isParameterDeclaration(declaration) ? declaration.getParent().getParent() : declaration.getParent();
 }
 function isWrittenAgain(declaration) {
   return assignmentsTo(declaration).length > 0;
 }
 function assignmentsTo(declaration) {
-  if (import_ts_morph21.Node.isPropertyDeclaration(declaration) || import_ts_morph21.Node.isParameterDeclaration(declaration)) {
+  if (import_ts_morph22.Node.isPropertyDeclaration(declaration) || import_ts_morph22.Node.isParameterDeclaration(declaration)) {
     const sourceFile2 = declaration.getSourceFile();
     return sourceFile2.isDeclarationFile() ? [] : assignmentsInFile(sourceFile2).get(declaration) ?? [];
   }
-  if (declaration.getVariableStatement()?.getDeclarationKind() === import_ts_morph21.VariableDeclarationKind.Const) {
+  if (declaration.getVariableStatement()?.getDeclarationKind() === import_ts_morph22.VariableDeclarationKind.Const) {
     return [];
   }
   const sourceFile = declaration.getSourceFile();
@@ -4902,39 +5028,39 @@ function assignmentsInFile(sourceFile) {
   return found;
 }
 function isAssignmentOperator(kind) {
-  return kind >= import_ts_morph21.SyntaxKind.FirstAssignment && kind <= import_ts_morph21.SyntaxKind.LastAssignment;
+  return kind >= import_ts_morph22.SyntaxKind.FirstAssignment && kind <= import_ts_morph22.SyntaxKind.LastAssignment;
 }
 function writeAt(node) {
-  if (import_ts_morph21.Node.isBinaryExpression(node)) {
+  if (import_ts_morph22.Node.isBinaryExpression(node)) {
     const operator = node.getOperatorToken().getKind();
     const target = node.getLeft();
-    if (!isAssignmentOperator(operator) || !(import_ts_morph21.Node.isIdentifier(target) || import_ts_morph21.Node.isPropertyAccessExpression(target))) {
+    if (!isAssignmentOperator(operator) || !(import_ts_morph22.Node.isIdentifier(target) || import_ts_morph22.Node.isPropertyAccessExpression(target))) {
       return null;
     }
-    const value = operator === import_ts_morph21.SyntaxKind.EqualsToken ? node.getRight() : null;
+    const value = operator === import_ts_morph22.SyntaxKind.EqualsToken ? node.getRight() : null;
     return { target, write: { value, node } };
   }
-  if (import_ts_morph21.Node.isPrefixUnaryExpression(node) || import_ts_morph21.Node.isPostfixUnaryExpression(node)) {
+  if (import_ts_morph22.Node.isPrefixUnaryExpression(node) || import_ts_morph22.Node.isPostfixUnaryExpression(node)) {
     const operator = node.getOperatorToken();
-    if (operator !== import_ts_morph21.SyntaxKind.PlusPlusToken && operator !== import_ts_morph21.SyntaxKind.MinusMinusToken) {
+    if (operator !== import_ts_morph22.SyntaxKind.PlusPlusToken && operator !== import_ts_morph22.SyntaxKind.MinusMinusToken) {
       return null;
     }
     const target = node.getOperand();
-    return import_ts_morph21.Node.isIdentifier(target) ? { target, write: { value: null, node } } : null;
+    return import_ts_morph22.Node.isIdentifier(target) ? { target, write: { value: null, node } } : null;
   }
   return null;
 }
 function declarationsOf(name) {
-  const nameNode = import_ts_morph21.Node.isPropertyAccessExpression(name) ? name.getNameNode() : name;
+  const nameNode = import_ts_morph22.Node.isPropertyAccessExpression(name) ? name.getNameNode() : name;
   const symbol = nameNode.getSymbol();
   if (symbol === void 0) {
     return [];
   }
   const declarations = [];
   for (const declaration of symbol.getDeclarations()) {
-    if (import_ts_morph21.Node.isVariableDeclaration(declaration) || import_ts_morph21.Node.isPropertyDeclaration(declaration) || // A parameter property is the field's only declaration, so
+    if (import_ts_morph22.Node.isVariableDeclaration(declaration) || import_ts_morph22.Node.isPropertyDeclaration(declaration) || // A parameter property is the field's only declaration, so
     // `this.dao = other` in the constructor writes to it.
-    import_ts_morph21.Node.isParameterDeclaration(declaration) && declaration.isParameterProperty()) {
+    import_ts_morph22.Node.isParameterDeclaration(declaration) && declaration.isParameterProperty()) {
       declarations.push(declaration);
     }
   }
@@ -4954,7 +5080,7 @@ function writesRunInOrder(declaration, writes) {
 function statementOf(node) {
   let current2 = node;
   while (current2 !== void 0) {
-    if (import_ts_morph21.Node.isStatement(current2)) {
+    if (import_ts_morph22.Node.isStatement(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -4978,7 +5104,7 @@ function isReadBefore(declaration, position) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph21.Node.isIdentifier(node) || node.getText() !== name) {
+    if (!import_ts_morph22.Node.isIdentifier(node) || node.getText() !== name) {
       return;
     }
     if (node === declaration.getNameNode() || isWriteTarget(node)) {
@@ -4991,17 +5117,17 @@ function isReadBefore(declaration, position) {
   return read2;
 }
 function startsItsOwnBody(node) {
-  return import_ts_morph21.Node.isFunctionDeclaration(node) || import_ts_morph21.Node.isFunctionExpression(node) || import_ts_morph21.Node.isArrowFunction(node) || import_ts_morph21.Node.isMethodDeclaration(node) || import_ts_morph21.Node.isClassDeclaration(node);
+  return import_ts_morph22.Node.isFunctionDeclaration(node) || import_ts_morph22.Node.isFunctionExpression(node) || import_ts_morph22.Node.isArrowFunction(node) || import_ts_morph22.Node.isMethodDeclaration(node) || import_ts_morph22.Node.isClassDeclaration(node);
 }
 function isWriteTarget(name) {
   const parent = name.getParent();
   if (parent === void 0) {
     return false;
   }
-  if (import_ts_morph21.Node.isBinaryExpression(parent)) {
+  if (import_ts_morph22.Node.isBinaryExpression(parent)) {
     return parent.getLeft() === name && isAssignmentOperator(parent.getOperatorToken().getKind());
   }
-  return (import_ts_morph21.Node.isPrefixUnaryExpression(parent) || import_ts_morph21.Node.isPostfixUnaryExpression(parent)) && parent.getOperand() === name;
+  return (import_ts_morph22.Node.isPrefixUnaryExpression(parent) || import_ts_morph22.Node.isPostfixUnaryExpression(parent)) && parent.getOperand() === name;
 }
 
 // src/terminals/statusBranches.ts
@@ -5027,10 +5153,10 @@ function asConditional(node) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph22.Node.isIdentifier(node)) {
+  if (!import_ts_morph23.Node.isIdentifier(node)) {
     return null;
   }
-  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph22.Node.isVariableDeclaration);
+  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph23.Node.isVariableDeclaration);
   if (declaration === void 0) {
     return null;
   }
@@ -5041,10 +5167,10 @@ function asConditional(node) {
   const only = written.values[0];
   return only === void 0 ? null : toConditional(only);
 }
-var toConditional = (node) => import_ts_morph22.Node.isConditionalExpression(node) ? node : null;
+var toConditional = (node) => import_ts_morph23.Node.isConditionalExpression(node) ? node : null;
 function numberOf(node) {
   const inner = unwrap(node);
-  if (!import_ts_morph22.Node.isNumericLiteral(inner)) {
+  if (!import_ts_morph23.Node.isNumericLiteral(inner)) {
     return null;
   }
   const value = Number(inner.getText());
@@ -5052,7 +5178,7 @@ function numberOf(node) {
 }
 function unwrap(node) {
   let current2 = node;
-  while (import_ts_morph22.Node.isParenthesizedExpression(current2) || import_ts_morph22.Node.isAsExpression(current2) || import_ts_morph22.Node.isNonNullExpression(current2)) {
+  while (import_ts_morph23.Node.isParenthesizedExpression(current2) || import_ts_morph23.Node.isAsExpression(current2) || import_ts_morph23.Node.isNonNullExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
@@ -5068,7 +5194,7 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
   for (let i = methodChain.length - 1; i >= 0; i--) {
     const expectedMethod = methodChain[i];
     const callee = current2.getExpression();
-    if (!import_ts_morph23.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph24.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     if (callee.getName() !== expectedMethod) {
@@ -5077,7 +5203,7 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
     collected.unshift(current2);
     const subject = callee.getExpression();
     if (i === 0) {
-      if (!import_ts_morph23.Node.isIdentifier(subject)) {
+      if (!import_ts_morph24.Node.isIdentifier(subject)) {
         return null;
       }
       const symbol = subject.getSymbol();
@@ -5089,7 +5215,7 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
         return null;
       }
       const decl = decls[0];
-      if (!import_ts_morph23.Node.isParameterDeclaration(decl)) {
+      if (!import_ts_morph24.Node.isParameterDeclaration(decl)) {
         return null;
       }
       const params = func.getParameters();
@@ -5098,7 +5224,7 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
         return null;
       }
     } else {
-      if (!import_ts_morph23.Node.isCallExpression(subject)) {
+      if (!import_ts_morph24.Node.isCallExpression(subject)) {
         return null;
       }
       current2 = subject;
@@ -5111,12 +5237,12 @@ function returnedValueOf(returnStatement) {
   return written === void 0 ? null : unwrapValue(written);
 }
 function tryMatchReturnShape(node, pattern, match, resolveWrittenValue) {
-  if (import_ts_morph23.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph24.Node.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
       return [];
     }
-    if (import_ts_morph23.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
+    if (import_ts_morph24.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
       return [];
     }
     const terminal = terminalFromReturnedObject(
@@ -5129,14 +5255,14 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue) {
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
-  if (!import_ts_morph23.Node.isReturnStatement(node)) {
+  if (!import_ts_morph24.Node.isReturnStatement(node)) {
     return [];
   }
   const returned = returnedValueOf(node);
   if (returned === null) {
     return [];
   }
-  if (import_ts_morph23.Node.isObjectLiteralExpression(returned)) {
+  if (import_ts_morph24.Node.isObjectLiteralExpression(returned)) {
     const terminal = terminalFromReturnedObject(
       returned,
       node,
@@ -5147,7 +5273,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue) {
     );
     return terminal === null ? [] : [terminal];
   }
-  if (!import_ts_morph23.Node.isCallExpression(returned)) {
+  if (!import_ts_morph24.Node.isCallExpression(returned)) {
     return [];
   }
   const resolved = resolveHelperReturn(returned);
@@ -5184,7 +5310,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_morph23.Node.isPropertyAssignment(prop) || import_ts_morph23.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph24.Node.isPropertyAssignment(prop) || import_ts_morph24.Node.isShorthandPropertyAssignment(prop)) {
         presentNames.add(prop.getName());
       }
     }
@@ -5210,7 +5336,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_morph23.Node.isReturnStatement(anchor) ? { source: anchor } : {},
+    ...import_ts_morph24.Node.isReturnStatement(anchor) ? { source: anchor } : {},
     terminal: {
       kind: pattern.kind,
       statusCode,
@@ -5229,7 +5355,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   };
 }
 function tryMatchParameterMethodCall(node, func, pattern, match, resolveWrittenValue) {
-  if (!import_ts_morph23.Node.isCallExpression(node)) {
+  if (!import_ts_morph24.Node.isCallExpression(node)) {
     return [];
   }
   const result = unwrapMethodChain(
@@ -5294,7 +5420,7 @@ function statusArgument(calls, extraction) {
 }
 function returnCoveredByParameterMethodCall(expr, func, patterns) {
   const current2 = unwrapValue(expr);
-  if (!import_ts_morph23.Node.isCallExpression(current2)) {
+  if (!import_ts_morph24.Node.isCallExpression(current2)) {
     return false;
   }
   for (const pattern of patterns) {
@@ -5315,7 +5441,7 @@ function returnCoveredByParameterMethodCall(expr, func, patterns) {
 }
 function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   const match = pattern.match.type === "returnStatement" ? pattern.match : null;
-  if (import_ts_morph23.Node.isReturnStatement(node)) {
+  if (import_ts_morph24.Node.isReturnStatement(node)) {
     const expr = node.getExpression();
     if (match?.excludeCallReturns === true) {
       if (expr === void 0) {
@@ -5334,9 +5460,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
     }
     return buildReturnTerminal(node, pattern, body);
   }
-  if (import_ts_morph23.Node.isArrowFunction(node)) {
+  if (import_ts_morph24.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body === void 0 || import_ts_morph23.Node.isBlock(body)) {
+    if (body === void 0 || import_ts_morph24.Node.isBlock(body)) {
       return null;
     }
     const shape = extractShape(body);
@@ -5403,20 +5529,20 @@ function unresolvedTerminal(kind, node) {
   };
 }
 function calleeSubject(callee) {
-  if (import_ts_morph23.Node.isIdentifier(callee)) {
+  if (import_ts_morph24.Node.isIdentifier(callee)) {
     return callee;
   }
-  if (import_ts_morph23.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph24.Node.isPropertyAccessExpression(callee)) {
     const subject = callee.getExpression();
-    return import_ts_morph23.Node.isIdentifier(subject) ? subject : null;
+    return import_ts_morph24.Node.isIdentifier(subject) ? subject : null;
   }
   return null;
 }
 function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue) {
-  if (!import_ts_morph23.Node.isCallExpression(node) && !import_ts_morph23.Node.isNewExpression(node)) {
+  if (!import_ts_morph24.Node.isCallExpression(node) && !import_ts_morph24.Node.isNewExpression(node)) {
     return null;
   }
-  if (import_ts_morph23.Node.isNewExpression(node) && returnPositionOf(node) === null) {
+  if (import_ts_morph24.Node.isNewExpression(node) && returnPositionOf(node) === null) {
     return null;
   }
   const callee = node.getExpression();
@@ -5455,9 +5581,9 @@ function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue) {
 }
 
 // src/terminals/throws.ts
-var import_ts_morph24 = require("ts-morph");
+var import_ts_morph25 = require("ts-morph");
 function tryMatchThrowExpression(node, pattern, match, resolveWrittenValue) {
-  if (!import_ts_morph24.Node.isThrowStatement(node)) {
+  if (!import_ts_morph25.Node.isThrowStatement(node)) {
     return null;
   }
   const thrownExpr = node.getExpression();
@@ -5499,17 +5625,17 @@ function extractThrowMessage(callArgs) {
     return null;
   }
   for (const arg of callArgs) {
-    if (import_ts_morph24.Node.isStringLiteral(arg) || import_ts_morph24.Node.isNoSubstitutionTemplateLiteral(arg)) {
+    if (import_ts_morph25.Node.isStringLiteral(arg) || import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(arg)) {
       return arg.getLiteralValue();
     }
-    if (import_ts_morph24.Node.isTemplateExpression(arg)) {
+    if (import_ts_morph25.Node.isTemplateExpression(arg)) {
       return arg.getText();
     }
   }
   return null;
 }
 function classifyThrownExpression(thrown, constructorPattern) {
-  if (import_ts_morph24.Node.isCallExpression(thrown) || import_ts_morph24.Node.isNewExpression(thrown)) {
+  if (import_ts_morph25.Node.isCallExpression(thrown) || import_ts_morph25.Node.isNewExpression(thrown)) {
     const calleeText = thrown.getExpression().getText();
     if (constructorPattern !== void 0 && !calleeText.startsWith(constructorPattern)) {
       return null;
@@ -5592,9 +5718,9 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
       }
     }
   });
-  if (results.length === 0 && import_ts_morph25.Node.isArrowFunction(func)) {
+  if (results.length === 0 && import_ts_morph26.Node.isArrowFunction(func)) {
     const body = func.getBody();
-    if (body !== void 0 && !import_ts_morph25.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph26.Node.isBlock(body)) {
       for (const pattern of patterns) {
         let found = null;
         if (pattern.match.type === "parameterMethodCall") {
@@ -5629,7 +5755,7 @@ function functionMayFallThrough(func) {
   if (body === void 0) {
     return false;
   }
-  if (!import_ts_morph25.Node.isBlock(body)) {
+  if (!import_ts_morph26.Node.isBlock(body)) {
     return false;
   }
   const statements = body.getStatements();
@@ -5637,7 +5763,7 @@ function functionMayFallThrough(func) {
     return true;
   }
   const last = statements[statements.length - 1];
-  if (import_ts_morph25.Node.isReturnStatement(last) || import_ts_morph25.Node.isThrowStatement(last)) {
+  if (import_ts_morph26.Node.isReturnStatement(last) || import_ts_morph26.Node.isThrowStatement(last)) {
     return false;
   }
   return true;
@@ -5672,7 +5798,7 @@ function bodyContentOf(func) {
   if (body === void 0) {
     return "absent";
   }
-  if (!import_ts_morph26.Node.isBlock(body)) {
+  if (!import_ts_morph27.Node.isBlock(body)) {
     return "statements";
   }
   return body.getStatements().length === 0 ? "empty" : "statements";
@@ -5688,7 +5814,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       claimed.add(source);
     }
   }
-  if (import_ts_morph26.Node.isArrowFunction(func) && import_ts_morph26.Node.isExpression(body)) {
+  if (import_ts_morph27.Node.isArrowFunction(func) && import_ts_morph27.Node.isExpression(body)) {
     return claimed.has(body) ? 0 : 1;
   }
   let unmatched = 0;
@@ -5701,7 +5827,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph26.Node.isReturnStatement(node)) {
+    if (!import_ts_morph27.Node.isReturnStatement(node)) {
       return;
     }
     if (node.getExpression() === void 0) {
@@ -5820,7 +5946,7 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
 }
 
 // src/bootstrap/sourceFileLookup.ts
-var import_ts_morph27 = require("ts-morph");
+var import_ts_morph28 = require("ts-morph");
 function createSourceFileLookup(project) {
   const all = project.getSourceFiles();
   const byAbs = /* @__PURE__ */ new Map();
@@ -5873,7 +5999,7 @@ function rangeKey(range) {
 function indexFunctions(sf) {
   const index = /* @__PURE__ */ new Map();
   sf.forEachDescendant((node) => {
-    if (!import_ts_morph27.Node.isFunctionDeclaration(node) && !import_ts_morph27.Node.isFunctionExpression(node) && !import_ts_morph27.Node.isArrowFunction(node) && !import_ts_morph27.Node.isMethodDeclaration(node)) {
+    if (!import_ts_morph28.Node.isFunctionDeclaration(node) && !import_ts_morph28.Node.isFunctionExpression(node) && !import_ts_morph28.Node.isArrowFunction(node) && !import_ts_morph28.Node.isMethodDeclaration(node)) {
       return;
     }
     const key = rangeKey({ start: startLineOf(node), end: endLineOf(node) });
@@ -6235,13 +6361,13 @@ function fileStampEquals(a, b) {
 }
 
 // src/contract.ts
-var import_ts_morph28 = require("ts-morph");
+var import_ts_morph29 = require("ts-morph");
 var import_behavioral_ir2 = require("@suss/behavioral-ir");
 function extractDeclaredBody(node) {
   if (node === void 0) {
     return null;
   }
-  if (!import_ts_morph28.Node.isCallExpression(node)) {
+  if (!import_ts_morph29.Node.isCallExpression(node)) {
     return null;
   }
   const typeArgs = node.getTypeArguments();
@@ -6255,10 +6381,10 @@ function resolveHandlerPropNode(func) {
   if (parent === void 0) {
     return null;
   }
-  if (import_ts_morph28.Node.isPropertyAssignment(parent)) {
+  if (import_ts_morph29.Node.isPropertyAssignment(parent)) {
     return parent;
   }
-  if (import_ts_morph28.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph29.Node.isMethodDeclaration(func)) {
     return func;
   }
   return null;
@@ -6270,11 +6396,11 @@ function findRouterCall(unit) {
     return null;
   }
   const handlersObj = propNode.getParent();
-  if (handlersObj === void 0 || !import_ts_morph28.Node.isObjectLiteralExpression(handlersObj)) {
+  if (handlersObj === void 0 || !import_ts_morph29.Node.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
   const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !import_ts_morph28.Node.isCallExpression(routerCall)) {
+  if (routerCall === void 0 || !import_ts_morph29.Node.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -6287,17 +6413,17 @@ function findRouterCall(unit) {
   };
 }
 function resolveContractObject(contractArg) {
-  if (import_ts_morph28.Node.isObjectLiteralExpression(contractArg)) {
+  if (import_ts_morph29.Node.isObjectLiteralExpression(contractArg)) {
     return contractArg;
   }
-  if (import_ts_morph28.Node.isPropertyAccessExpression(contractArg)) {
+  if (import_ts_morph29.Node.isPropertyAccessExpression(contractArg)) {
     const base = resolveContractObject(contractArg.getExpression());
-    if (base === null || !import_ts_morph28.Node.isObjectLiteralExpression(base)) {
+    if (base === null || !import_ts_morph29.Node.isObjectLiteralExpression(base)) {
       return null;
     }
     const propName = contractArg.getName();
     for (const prop of base.getProperties()) {
-      if (!import_ts_morph28.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph29.Node.isPropertyAssignment(prop)) {
         continue;
       }
       if (prop.getName() !== propName) {
@@ -6307,20 +6433,20 @@ function resolveContractObject(contractArg) {
       if (value === void 0) {
         return null;
       }
-      if (import_ts_morph28.Node.isObjectLiteralExpression(value)) {
+      if (import_ts_morph29.Node.isObjectLiteralExpression(value)) {
         return value;
       }
-      if (import_ts_morph28.Node.isIdentifier(value) || import_ts_morph28.Node.isPropertyAccessExpression(value)) {
+      if (import_ts_morph29.Node.isIdentifier(value) || import_ts_morph29.Node.isPropertyAccessExpression(value)) {
         return resolveContractObject(value);
       }
-      if (import_ts_morph28.Node.isCallExpression(value)) {
+      if (import_ts_morph29.Node.isCallExpression(value)) {
         return unwrapContractInit(value);
       }
       return null;
     }
     return null;
   }
-  if (!import_ts_morph28.Node.isIdentifier(contractArg)) {
+  if (!import_ts_morph29.Node.isIdentifier(contractArg)) {
     return null;
   }
   const symbol = contractArg.getSymbol();
@@ -6332,21 +6458,21 @@ function resolveContractObject(contractArg) {
     return null;
   }
   const decl = decls[0];
-  if (import_ts_morph28.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph29.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sourceFile = importDecl.getModuleSpecifierSourceFile();
     if (sourceFile !== void 0) {
       const exported = exportedDeclarationsOf(sourceFile).get(decl.getName());
       if (exported !== void 0 && exported.length > 0) {
         const exportedDecl = exported[0];
-        if (import_ts_morph28.Node.isVariableDeclaration(exportedDecl)) {
+        if (import_ts_morph29.Node.isVariableDeclaration(exportedDecl)) {
           return unwrapContractInit(exportedDecl.getInitializer());
         }
       }
     }
     return null;
   }
-  if (import_ts_morph28.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph29.Node.isVariableDeclaration(decl)) {
     return unwrapContractInit(decl.getInitializer());
   }
   return null;
@@ -6356,50 +6482,50 @@ function unwrapContractInit(init) {
     return null;
   }
   let node = init;
-  while (import_ts_morph28.Node.isAsExpression(node)) {
+  while (import_ts_morph29.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
-  if (import_ts_morph28.Node.isCallExpression(node)) {
+  if (import_ts_morph29.Node.isCallExpression(node)) {
     const args = node.getArguments();
-    if (args.length > 0 && import_ts_morph28.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length > 0 && import_ts_morph29.Node.isObjectLiteralExpression(args[0])) {
       return args[0];
     }
     return null;
   }
-  if (import_ts_morph28.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph29.Node.isObjectLiteralExpression(node)) {
     return node;
   }
   return null;
 }
 function extractEndpointContract(endpointNode, pattern, framework) {
-  if (!import_ts_morph28.Node.isObjectLiteralExpression(endpointNode)) {
+  if (!import_ts_morph29.Node.isObjectLiteralExpression(endpointNode)) {
     return null;
   }
   const responses = [];
   let method;
   let path13;
   for (const prop of endpointNode.getProperties()) {
-    if (!import_ts_morph28.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph29.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const propName = prop.getName();
     if (propName === pattern.methodProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph28.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph29.Node.isStringLiteral(val)) {
         method = val.getLiteralValue();
       }
     }
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph28.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph29.Node.isStringLiteral(val)) {
         path13 = val.getLiteralValue();
       }
     }
     if (propName === pattern.responseExtraction.property) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph28.Node.isObjectLiteralExpression(val)) {
+      if (val !== void 0 && import_ts_morph29.Node.isObjectLiteralExpression(val)) {
         for (const respProp of val.getProperties()) {
-          if (!import_ts_morph28.Node.isPropertyAssignment(respProp)) {
+          if (!import_ts_morph29.Node.isPropertyAssignment(respProp)) {
             continue;
           }
           const statusStr = respProp.getName();
@@ -6443,11 +6569,11 @@ function readContract(unit, pattern, framework) {
     return null;
   }
   const contractObj = resolveContractObject(routerInfo.contractArg);
-  if (contractObj === null || !import_ts_morph28.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph29.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph28.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph29.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== routerInfo.handlerName) {
@@ -6467,7 +6593,7 @@ function endpointFromRegistrationArgument(unit, position) {
     return null;
   }
   const call = func.getParent();
-  if (call === void 0 || !import_ts_morph28.Node.isCallExpression(call)) {
+  if (call === void 0 || !import_ts_morph29.Node.isCallExpression(call)) {
     return null;
   }
   const args = call.getArguments();
@@ -6479,24 +6605,24 @@ function endpointFromRegistrationArgument(unit, position) {
     return null;
   }
   let node = arg;
-  while (import_ts_morph28.Node.isAsExpression(node)) {
+  while (import_ts_morph29.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
-  if (import_ts_morph28.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph29.Node.isObjectLiteralExpression(node)) {
     return node;
   }
-  if (import_ts_morph28.Node.isCallExpression(node)) {
+  if (import_ts_morph29.Node.isCallExpression(node)) {
     return unwrapContractInit(node);
   }
   return resolveContractObject(node);
 }
 function readContractForClientCall(callExpression, methodName, pattern, framework) {
-  const callee = import_ts_morph28.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
-  if (callee === null || !import_ts_morph28.Node.isPropertyAccessExpression(callee)) {
+  const callee = import_ts_morph29.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
+  if (callee === null || !import_ts_morph29.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   const clientIdentifier = callee.getExpression();
-  if (!import_ts_morph28.Node.isIdentifier(clientIdentifier)) {
+  if (!import_ts_morph29.Node.isIdentifier(clientIdentifier)) {
     return null;
   }
   const symbol = clientIdentifier.getSymbol();
@@ -6508,11 +6634,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const decl = decls[0];
-  if (!import_ts_morph28.Node.isVariableDeclaration(decl)) {
+  if (!import_ts_morph29.Node.isVariableDeclaration(decl)) {
     return null;
   }
   const init = decl.getInitializer();
-  if (init === void 0 || !import_ts_morph28.Node.isCallExpression(init)) {
+  if (init === void 0 || !import_ts_morph29.Node.isCallExpression(init)) {
     return null;
   }
   const args = init.getArguments();
@@ -6520,11 +6646,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const contractObj = resolveContractObject(args[0]);
-  if (contractObj === null || !import_ts_morph28.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph29.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph28.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph29.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== methodName) {
@@ -6541,7 +6667,7 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
 
 // src/diagnostics.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var import_ts_morph29 = require("ts-morph");
+var import_ts_morph30 = require("ts-morph");
 var import_behavioral_ir3 = require("@suss/behavioral-ir");
 var emptyTally = () => ({
   candidateFiles: 0,
@@ -6589,23 +6715,23 @@ function commonDirectoryOf(files) {
   return joined.length > 1 ? joined : void 0;
 }
 var DEFAULT_RESOLUTION = {
-  moduleResolution: import_ts_morph29.ts.ModuleResolutionKind.Bundler,
-  target: import_ts_morph29.ts.ScriptTarget.ESNext,
-  module: import_ts_morph29.ts.ModuleKind.ESNext
+  moduleResolution: import_ts_morph30.ts.ModuleResolutionKind.Bundler,
+  target: import_ts_morph30.ts.ScriptTarget.ESNext,
+  module: import_ts_morph30.ts.ModuleKind.ESNext
 };
 function resolutionContext(args) {
   if (args.tsConfigFilePath !== void 0) {
-    const configFile = import_ts_morph29.ts.readConfigFile(
+    const configFile = import_ts_morph30.ts.readConfigFile(
       args.tsConfigFilePath,
-      import_ts_morph29.ts.sys.readFile
+      import_ts_morph30.ts.sys.readFile
     );
     if (configFile.error !== void 0) {
       return null;
     }
     const dir = import_node_path3.default.dirname(args.tsConfigFilePath);
-    const parsed = import_ts_morph29.ts.parseJsonConfigFileContent(
+    const parsed = import_ts_morph30.ts.parseJsonConfigFileContent(
       configFile.config,
-      import_ts_morph29.ts.sys,
+      import_ts_morph30.ts.sys,
       dir,
       /*existingOptions*/
       void 0,
@@ -6634,11 +6760,11 @@ function unresolvedGatesFor(gates, args) {
   }
   const unresolved = [];
   for (const gate of gates) {
-    const resolved = import_ts_morph29.ts.resolveModuleName(
+    const resolved = import_ts_morph30.ts.resolveModuleName(
       gate,
       context.containingFile,
       context.options,
-      import_ts_morph29.ts.sys
+      import_ts_morph30.ts.sys
     );
     if (resolved.resolvedModule === void 0) {
       unresolved.push(gate);
@@ -6804,17 +6930,17 @@ function parameterName(segment, convention) {
 
 // src/discovery/graphqlClientConstruction.ts
 var import_picomatch = __toESM(require("picomatch"), 1);
-var import_ts_morph33 = require("ts-morph");
+var import_ts_morph34 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 
 // src/discovery/resolveValue.ts
-var import_ts_morph32 = require("ts-morph");
+var import_ts_morph33 = require("ts-morph");
 
 // src/facts/extract.ts
-var import_ts_morph31 = require("ts-morph");
+var import_ts_morph32 = require("ts-morph");
 
 // src/discovery/shared.ts
-var import_ts_morph30 = require("ts-morph");
+var import_ts_morph31 = require("ts-morph");
 function unitNode(unit) {
   return unit.func ?? unit.announcedAt ?? null;
 }
@@ -6838,37 +6964,37 @@ function unitDedupKey(unit) {
   return parts.join("-");
 }
 function isFunctionRoot(node) {
-  return import_ts_morph30.Node.isFunctionDeclaration(node) || import_ts_morph30.Node.isFunctionExpression(node) || import_ts_morph30.Node.isArrowFunction(node) || import_ts_morph30.Node.isMethodDeclaration(node);
+  return import_ts_morph31.Node.isFunctionDeclaration(node) || import_ts_morph31.Node.isFunctionExpression(node) || import_ts_morph31.Node.isArrowFunction(node) || import_ts_morph31.Node.isMethodDeclaration(node);
 }
 function declarationCarryingTheBody(declaration) {
-  if (!import_ts_morph30.Node.isFunctionDeclaration(declaration) && !import_ts_morph30.Node.isMethodDeclaration(declaration)) {
+  if (!import_ts_morph31.Node.isFunctionDeclaration(declaration) && !import_ts_morph31.Node.isMethodDeclaration(declaration)) {
     return declaration;
   }
   return declaration.getImplementation() ?? declaration;
 }
 function couldResolveToFunction(value) {
-  return import_ts_morph30.Node.isCallExpression(value) || import_ts_morph30.Node.isIdentifier(value) || import_ts_morph30.Node.isPropertyAccessExpression(value) || import_ts_morph30.Node.isExportSpecifier(value) || import_ts_morph30.Node.isImportSpecifier(value) || import_ts_morph30.Node.isImportClause(value) || import_ts_morph30.Node.isBindingElement(value);
+  return import_ts_morph31.Node.isCallExpression(value) || import_ts_morph31.Node.isIdentifier(value) || import_ts_morph31.Node.isPropertyAccessExpression(value) || import_ts_morph31.Node.isExportSpecifier(value) || import_ts_morph31.Node.isImportSpecifier(value) || import_ts_morph31.Node.isImportClause(value) || import_ts_morph31.Node.isBindingElement(value);
 }
 function couldStillNameAFunction(value) {
   if (!couldResolveToFunction(value)) {
     return false;
   }
-  if (!import_ts_morph30.Node.isIdentifier(value)) {
+  if (!import_ts_morph31.Node.isIdentifier(value)) {
     return true;
   }
   const declaration = value.getSymbol()?.getDeclarations()?.[0];
-  if (declaration === void 0 || !import_ts_morph30.Node.isVariableDeclaration(declaration)) {
+  if (declaration === void 0 || !import_ts_morph31.Node.isVariableDeclaration(declaration)) {
     return true;
   }
   const written = declaration.getInitializer();
   return written === void 0 || isFunctionRoot(written) || couldResolveToFunction(written);
 }
 function namesAParameter(value) {
-  if (!import_ts_morph30.Node.isIdentifier(value)) {
+  if (!import_ts_morph31.Node.isIdentifier(value)) {
     return false;
   }
   const declaration = value.getSymbol()?.getDeclarations()?.[0];
-  return declaration !== void 0 && import_ts_morph30.Node.isParameterDeclaration(declaration);
+  return declaration !== void 0 && import_ts_morph31.Node.isParameterDeclaration(declaration);
 }
 function toFunctionRoot(node) {
   return isFunctionRoot(node) ? declarationCarryingTheBody(node) : null;
@@ -6876,7 +7002,7 @@ function toFunctionRoot(node) {
 function findEnclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph30.Node.isFunctionDeclaration(current2) || import_ts_morph30.Node.isFunctionExpression(current2) || import_ts_morph30.Node.isArrowFunction(current2) || import_ts_morph30.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph31.Node.isFunctionDeclaration(current2) || import_ts_morph31.Node.isFunctionExpression(current2) || import_ts_morph31.Node.isArrowFunction(current2) || import_ts_morph31.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -6909,10 +7035,10 @@ function moduleKeyOf(declaration) {
 }
 function importOriginsOf(callee) {
   let root = callee;
-  while (import_ts_morph31.Node.isPropertyAccessExpression(root)) {
+  while (import_ts_morph32.Node.isPropertyAccessExpression(root)) {
     root = root.getExpression();
   }
-  if (!import_ts_morph31.Node.isIdentifier(root)) {
+  if (!import_ts_morph32.Node.isIdentifier(root)) {
     return [];
   }
   const symbol = root.getSymbol();
@@ -6927,7 +7053,7 @@ function importOriginsOf(callee) {
       origins.add(packagePartOf(specifier));
     }
   }
-  const named2 = import_ts_morph31.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : void 0;
+  const named2 = import_ts_morph32.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : void 0;
   for (const candidate of [named2 ?? symbol, symbol]) {
     const aliased = resolveAliasedSymbol(candidate) ?? candidate;
     for (const declaration of aliased.getDeclarations()) {
@@ -6944,17 +7070,17 @@ function importOriginsOf(callee) {
   return [...origins];
 }
 function importSpecifierOf(declaration) {
-  if (import_ts_morph31.Node.isImportSpecifier(declaration)) {
+  if (import_ts_morph32.Node.isImportSpecifier(declaration)) {
     return declaration.getImportDeclaration().getModuleSpecifierValue();
   }
-  if (import_ts_morph31.Node.isImportEqualsDeclaration(declaration)) {
+  if (import_ts_morph32.Node.isImportEqualsDeclaration(declaration)) {
     const reference = declaration.getModuleReference();
-    return import_ts_morph31.Node.isExternalModuleReference(reference) ? reference.getExpression()?.getText().slice(1, -1) ?? null : null;
+    return import_ts_morph32.Node.isExternalModuleReference(reference) ? reference.getExpression()?.getText().slice(1, -1) ?? null : null;
   }
-  const owner = import_ts_morph31.Node.isNamespaceImport(declaration) ? declaration.getParent() : declaration;
-  if (import_ts_morph31.Node.isImportClause(owner)) {
+  const owner = import_ts_morph32.Node.isNamespaceImport(declaration) ? declaration.getParent() : declaration;
+  if (import_ts_morph32.Node.isImportClause(owner)) {
     const importDecl = owner.getParent();
-    if (import_ts_morph31.Node.isImportDeclaration(importDecl)) {
+    if (import_ts_morph32.Node.isImportDeclaration(importDecl)) {
       return importDecl.getModuleSpecifierValue();
     }
   }
@@ -6966,7 +7092,7 @@ function packagePartOf(specifier) {
   return parts.slice(0, take).join("/");
 }
 function declaresAValue(declaration) {
-  return !import_ts_morph31.Node.isPropertySignature(declaration) && !import_ts_morph31.Node.isMethodSignature(declaration);
+  return !import_ts_morph32.Node.isPropertySignature(declaration) && !import_ts_morph32.Node.isMethodSignature(declaration);
 }
 function packagesDeclaring(filePath) {
   const marker = "/node_modules/";
@@ -6990,39 +7116,39 @@ function packagesDescribedByTypes(owner) {
   return scoped.length === 2 ? [name, `@${scoped[0]}/${scoped[1]}`] : [name];
 }
 function factKeyOf(value) {
-  return import_ts_morph31.Node.isExpression(value) ? unwrapExpression(value) : value;
+  return import_ts_morph32.Node.isExpression(value) ? unwrapExpression(value) : value;
 }
 function literalIndexOf(index) {
   if (index === void 0) {
     return null;
   }
-  if (import_ts_morph31.Node.isNumericLiteral(index)) {
+  if (import_ts_morph32.Node.isNumericLiteral(index)) {
     return String(index.getLiteralValue());
   }
-  if (import_ts_morph31.Node.isStringLiteral(index) || import_ts_morph31.Node.isNoSubstitutionTemplateLiteral(index)) {
+  if (import_ts_morph32.Node.isStringLiteral(index) || import_ts_morph32.Node.isNoSubstitutionTemplateLiteral(index)) {
     return index.getLiteralValue();
   }
   return null;
 }
 function asFallbackExpression(expression) {
-  if (!import_ts_morph31.Node.isBinaryExpression(expression)) {
+  if (!import_ts_morph32.Node.isBinaryExpression(expression)) {
     return null;
   }
   const operator = expression.getOperatorToken().getKind();
-  return operator === import_ts_morph31.SyntaxKind.BarBarToken || operator === import_ts_morph31.SyntaxKind.QuestionQuestionToken ? expression : null;
+  return operator === import_ts_morph32.SyntaxKind.BarBarToken || operator === import_ts_morph32.SyntaxKind.QuestionQuestionToken ? expression : null;
 }
 function unwrapExpression(expression) {
   let current2 = expression;
   for (; ; ) {
-    if (import_ts_morph31.Node.isAwaitExpression(current2)) {
+    if (import_ts_morph32.Node.isAwaitExpression(current2)) {
       current2 = current2.getExpression();
       continue;
     }
-    if (import_ts_morph31.Node.isParenthesizedExpression(current2)) {
+    if (import_ts_morph32.Node.isParenthesizedExpression(current2)) {
       current2 = current2.getExpression();
       continue;
     }
-    if (import_ts_morph31.Node.isAsExpression(current2) || import_ts_morph31.Node.isSatisfiesExpression(current2)) {
+    if (import_ts_morph32.Node.isAsExpression(current2) || import_ts_morph32.Node.isSatisfiesExpression(current2)) {
       current2 = current2.getExpression();
       continue;
     }
@@ -7042,7 +7168,7 @@ function emitValue(db, table, value) {
     emitFunctionFacts(db, table, expression);
     return id;
   }
-  if (import_ts_morph31.Node.isPropertyAccessExpression(expression)) {
+  if (import_ts_morph32.Node.isPropertyAccessExpression(expression)) {
     fact(
       db,
       "readsProperty",
@@ -7053,11 +7179,11 @@ function emitValue(db, table, value) {
     emitReferenceFacts(db, table, expression);
     return id;
   }
-  if (import_ts_morph31.Node.isIdentifier(expression)) {
+  if (import_ts_morph32.Node.isIdentifier(expression)) {
     emitReferenceFacts(db, table, expression);
     return id;
   }
-  if (import_ts_morph31.Node.isElementAccessExpression(expression)) {
+  if (import_ts_morph32.Node.isElementAccessExpression(expression)) {
     const index = literalIndexOf(expression.getArgumentExpression());
     if (index !== null) {
       fact(
@@ -7072,7 +7198,7 @@ function emitValue(db, table, value) {
     fact(db, "writtenValue", id);
     return id;
   }
-  if (import_ts_morph31.Node.isArrayLiteralExpression(expression)) {
+  if (import_ts_morph32.Node.isArrayLiteralExpression(expression)) {
     fact(db, "objectValue", id);
     const elements = expression.getElements();
     for (let position = 0; position < elements.length; position++) {
@@ -7090,10 +7216,10 @@ function emitValue(db, table, value) {
     }
     return id;
   }
-  if (import_ts_morph31.Node.isObjectLiteralExpression(expression)) {
+  if (import_ts_morph32.Node.isObjectLiteralExpression(expression)) {
     fact(db, "objectValue", id);
     for (const property of expression.getProperties()) {
-      if (import_ts_morph31.Node.isPropertyAssignment(property)) {
+      if (import_ts_morph32.Node.isPropertyAssignment(property)) {
         const held = property.getInitializer();
         if (held !== void 0) {
           fact(
@@ -7104,7 +7230,7 @@ function emitValue(db, table, value) {
             emitValue(db, table, held)
           );
         }
-      } else if (import_ts_morph31.Node.isShorthandPropertyAssignment(property)) {
+      } else if (import_ts_morph32.Node.isShorthandPropertyAssignment(property)) {
         fact(
           db,
           "holdsProperty",
@@ -7112,7 +7238,7 @@ function emitValue(db, table, value) {
           property.getName(),
           emitValue(db, table, property.getNameNode())
         );
-      } else if (import_ts_morph31.Node.isMethodDeclaration(property)) {
+      } else if (import_ts_morph32.Node.isMethodDeclaration(property)) {
         const methodId = nodeId(property);
         table.byId.set(methodId, property);
         fact(db, "func", methodId);
@@ -7128,7 +7254,7 @@ function emitValue(db, table, value) {
     fact(db, "fallbackBranch", id, emitValue(db, table, fallback.getRight()));
     return id;
   }
-  if (import_ts_morph31.Node.isCallExpression(expression) || import_ts_morph31.Node.isNewExpression(expression)) {
+  if (import_ts_morph32.Node.isCallExpression(expression) || import_ts_morph32.Node.isNewExpression(expression)) {
     emitCallFacts(db, table, expression);
     fact(db, "writtenValue", id);
     return id;
@@ -7155,7 +7281,7 @@ function emitBindingValues(db, table, declaration) {
 function emitFieldValues(db, table, declaration) {
   const { values, inOrder } = writesToField(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0 || !import_ts_morph31.Node.isExpression(last)) {
+  if (!inOrder || last === void 0 || !import_ts_morph32.Node.isExpression(last)) {
     return;
   }
   fact(db, "binds", nodeId(declaration), emitValue(db, table, last));
@@ -7166,7 +7292,7 @@ function emitParameterPropertyRead(db, table, referenceId, declaration) {
   if (!inOrder || last === void 0) {
     return;
   }
-  if (!import_ts_morph31.Node.isExpression(last)) {
+  if (!import_ts_morph32.Node.isExpression(last)) {
     table.byId.set(nodeId(last), last);
     fact(db, "binds", referenceId, nodeId(last));
     return;
@@ -7181,7 +7307,7 @@ function emitBindingElementFacts(db, table, element) {
   }
   table.seenBindings.add(element);
   const pattern = element.getParent();
-  const container = import_ts_morph31.Node.isObjectBindingPattern(pattern) ? containerOfBindingPattern(pattern) : void 0;
+  const container = import_ts_morph32.Node.isObjectBindingPattern(pattern) ? containerOfBindingPattern(pattern) : void 0;
   if (container !== void 0) {
     const property = element.getPropertyNameNode() ?? element.getNameNode();
     fact(
@@ -7200,11 +7326,11 @@ function emitBindingElementFacts(db, table, element) {
 }
 function containerOfBindingPattern(pattern) {
   const declaration = pattern.getParent();
-  return import_ts_morph31.Node.isVariableDeclaration(declaration) ? declaration.getInitializer() : void 0;
+  return import_ts_morph32.Node.isVariableDeclaration(declaration) ? declaration.getInitializer() : void 0;
 }
 function referencedSymbol(nameNode) {
   const parent = nameNode.getParent();
-  if (parent !== void 0 && import_ts_morph31.Node.isShorthandPropertyAssignment(parent) && parent.getNameNode() === nameNode) {
+  if (parent !== void 0 && import_ts_morph32.Node.isShorthandPropertyAssignment(parent) && parent.getNameNode() === nameNode) {
     return parent.getValueSymbol();
   }
   return nameNode.getSymbol();
@@ -7212,7 +7338,7 @@ function referencedSymbol(nameNode) {
 function emitReferenceFacts(db, table, reference) {
   const referenceId = nodeId(reference);
   table.byId.set(referenceId, reference);
-  const nameNode = import_ts_morph31.Node.isPropertyAccessExpression(reference) ? reference.getNameNode() : reference;
+  const nameNode = import_ts_morph32.Node.isPropertyAccessExpression(reference) ? reference.getNameNode() : reference;
   const symbol = referencedSymbol(nameNode);
   if (symbol === void 0) {
     return;
@@ -7221,7 +7347,7 @@ function emitReferenceFacts(db, table, reference) {
     const declaration = declarationCarryingTheBody(spelling);
     const declarationId = nodeId(declaration);
     table.byId.set(declarationId, declaration);
-    if (import_ts_morph31.Node.isImportSpecifier(declaration)) {
+    if (import_ts_morph32.Node.isImportSpecifier(declaration)) {
       const importDecl = declaration.getImportDeclaration();
       const moduleKey = moduleKeyOf(importDecl);
       if (moduleKey !== null) {
@@ -7230,9 +7356,9 @@ function emitReferenceFacts(db, table, reference) {
       }
       continue;
     }
-    if (import_ts_morph31.Node.isImportClause(declaration)) {
+    if (import_ts_morph32.Node.isImportClause(declaration)) {
       const importDecl = declaration.getParentIfKind(
-        import_ts_morph31.SyntaxKind.ImportDeclaration
+        import_ts_morph32.SyntaxKind.ImportDeclaration
       );
       if (importDecl !== void 0) {
         const moduleKey = moduleKeyOf(importDecl);
@@ -7243,30 +7369,30 @@ function emitReferenceFacts(db, table, reference) {
       }
       continue;
     }
-    if (import_ts_morph31.Node.isVariableDeclaration(declaration)) {
+    if (import_ts_morph32.Node.isVariableDeclaration(declaration)) {
       fact(db, "binds", referenceId, declarationId);
       emitBindingValues(db, table, declaration);
       continue;
     }
-    if (import_ts_morph31.Node.isPropertyDeclaration(declaration)) {
+    if (import_ts_morph32.Node.isPropertyDeclaration(declaration)) {
       fact(db, "binds", referenceId, declarationId);
       emitFieldValues(db, table, declaration);
       continue;
     }
-    if (import_ts_morph31.Node.isParameterDeclaration(declaration)) {
-      if (declaration.isParameterProperty() && import_ts_morph31.Node.isPropertyAccessExpression(reference)) {
+    if (import_ts_morph32.Node.isParameterDeclaration(declaration)) {
+      if (declaration.isParameterProperty() && import_ts_morph32.Node.isPropertyAccessExpression(reference)) {
         emitParameterPropertyRead(db, table, referenceId, declaration);
       } else {
         fact(db, "binds", referenceId, declarationId);
       }
       continue;
     }
-    if (import_ts_morph31.Node.isClassDeclaration(declaration)) {
+    if (import_ts_morph32.Node.isClassDeclaration(declaration)) {
       fact(db, "binds", referenceId, declarationId);
       emitClassFacts(db, table, declaration);
       continue;
     }
-    if (import_ts_morph31.Node.isBindingElement(declaration)) {
+    if (import_ts_morph32.Node.isBindingElement(declaration)) {
       fact(db, "binds", referenceId, declarationId);
       emitBindingElementFacts(db, table, declaration);
       continue;
@@ -7282,7 +7408,7 @@ function emitCallFacts(db, table, call) {
   const callId = nodeId(call);
   table.byId.set(callId, call);
   const callee = unwrapExpression(call.getExpression());
-  if (import_ts_morph31.Node.isPropertyAccessExpression(callee) && callee.getName() === "bind") {
+  if (import_ts_morph32.Node.isPropertyAccessExpression(callee) && callee.getName() === "bind") {
     const target = unwrapExpression(callee.getExpression());
     fact(db, "bindCall", callId, emitValue(db, table, target));
     return;
@@ -7295,7 +7421,7 @@ function emitCallFacts(db, table, call) {
   const args = call.getArguments();
   for (let position = 0; position < args.length; position++) {
     const argument = args[position];
-    if (!import_ts_morph31.Node.isExpression(argument)) {
+    if (!import_ts_morph32.Node.isExpression(argument)) {
       continue;
     }
     fact(
@@ -7362,11 +7488,11 @@ function emitFunctionFacts(db, table, fn) {
   table.seenFunctions.add(fn);
   const fnId = nodeId(fn);
   table.byId.set(fnId, fn);
-  if (import_ts_morph31.Node.isFunctionDeclaration(fn) || import_ts_morph31.Node.isFunctionExpression(fn) || import_ts_morph31.Node.isArrowFunction(fn) || import_ts_morph31.Node.isMethodDeclaration(fn)) {
+  if (import_ts_morph32.Node.isFunctionDeclaration(fn) || import_ts_morph32.Node.isFunctionExpression(fn) || import_ts_morph32.Node.isArrowFunction(fn) || import_ts_morph32.Node.isMethodDeclaration(fn)) {
     emitParameters(db, table, fnId, fn.getParameters());
     const body = fn.getBody?.();
     if (body !== void 0) {
-      if (import_ts_morph31.Node.isExpression(body)) {
+      if (import_ts_morph32.Node.isExpression(body)) {
         fact(db, "returnsValue", fnId, emitValue(db, table, body));
         recordBodyNode(db, table, fnId, body);
       }
@@ -7388,20 +7514,20 @@ function recordBodyNode(db, table, fnId, node) {
     fact(db, "containsFn", fnId, nodeId(node));
     return true;
   }
-  if (import_ts_morph31.Node.isReturnStatement(node)) {
+  if (import_ts_morph32.Node.isReturnStatement(node)) {
     const returned = node.getExpression();
     if (returned !== void 0) {
       fact(db, "returnsValue", fnId, emitValue(db, table, returned));
     }
     return false;
   }
-  if (!import_ts_morph31.Node.isExpression(node)) {
+  if (!import_ts_morph32.Node.isExpression(node)) {
     return false;
   }
   const call = unwrapExpression(node);
-  if (import_ts_morph31.Node.isCallExpression(call)) {
+  if (import_ts_morph32.Node.isCallExpression(call)) {
     const callee = unwrapExpression(call.getExpression());
-    if (import_ts_morph31.Node.isIdentifier(callee) || import_ts_morph31.Node.isPropertyAccessExpression(callee)) {
+    if (import_ts_morph32.Node.isIdentifier(callee) || import_ts_morph32.Node.isPropertyAccessExpression(callee)) {
       fact(db, "bodyCalls", fnId, emitValue(db, table, callee));
     }
   }
@@ -7410,10 +7536,10 @@ function recordBodyNode(db, table, fnId, node) {
 function descendantIsReturned(fn) {
   let current2 = fn.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph31.Node.isReturnStatement(current2)) {
+    if (import_ts_morph32.Node.isReturnStatement(current2)) {
       return true;
     }
-    if (import_ts_morph31.Node.isParenthesizedExpression(current2) || import_ts_morph31.Node.isAsExpression(current2) || import_ts_morph31.Node.isSatisfiesExpression(current2)) {
+    if (import_ts_morph32.Node.isParenthesizedExpression(current2) || import_ts_morph32.Node.isAsExpression(current2) || import_ts_morph32.Node.isSatisfiesExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -7460,19 +7586,19 @@ function extractFileFacts(db, table, sourceFile) {
         fact(db, "exportsAs", filePath, name, id);
         continue;
       }
-      if (import_ts_morph31.Node.isClassDeclaration(declaration)) {
+      if (import_ts_morph32.Node.isClassDeclaration(declaration)) {
         emitClassFacts(db, table, declaration);
         fact(db, "exportsAs", filePath, name, nodeId(declaration));
         continue;
       }
-      if (import_ts_morph31.Node.isVariableDeclaration(declaration)) {
+      if (import_ts_morph32.Node.isVariableDeclaration(declaration)) {
         const declarationId = nodeId(declaration);
         table.byId.set(declarationId, declaration);
         fact(db, "exportsAs", filePath, name, declarationId);
         emitBindingValues(db, table, declaration);
         continue;
       }
-      if (import_ts_morph31.Node.isBindingElement(declaration)) {
+      if (import_ts_morph32.Node.isBindingElement(declaration)) {
         fact(
           db,
           "exportsAs",
@@ -7482,7 +7608,7 @@ function extractFileFacts(db, table, sourceFile) {
         );
         continue;
       }
-      if (import_ts_morph31.Node.isExpression(declaration)) {
+      if (import_ts_morph32.Node.isExpression(declaration)) {
         fact(
           db,
           "exportsAs",
@@ -7497,13 +7623,13 @@ function extractFileFacts(db, table, sourceFile) {
 
 // src/discovery/resolveValue.ts
 function couldNameAValue(value) {
-  return import_ts_morph32.Node.isIdentifier(value) || import_ts_morph32.Node.isPropertyAccessExpression(value) || import_ts_morph32.Node.isElementAccessExpression(value) || import_ts_morph32.Node.isCallExpression(value);
+  return import_ts_morph33.Node.isIdentifier(value) || import_ts_morph33.Node.isPropertyAccessExpression(value) || import_ts_morph33.Node.isElementAccessExpression(value) || import_ts_morph33.Node.isCallExpression(value);
 }
 function propertyValueOf(property) {
-  if (import_ts_morph32.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph33.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph32.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph33.Node.isShorthandPropertyAssignment(property)) {
     return property.getNameNode();
   }
   return null;
@@ -7524,7 +7650,7 @@ function objectLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph32.Node.isObjectLiteralExpression(node)
+    (node) => import_ts_morph33.Node.isObjectLiteralExpression(node)
   );
 }
 function propertiesOf(object, resolution) {
@@ -7536,7 +7662,7 @@ function propertiesReached(object, resolution, seen) {
   }
   seen.add(object);
   return object.getProperties().flatMap((property) => {
-    if (!import_ts_morph32.Node.isSpreadAssignment(property)) {
+    if (!import_ts_morph33.Node.isSpreadAssignment(property)) {
       return [property];
     }
     const spread = objectLiteralOf(property.getExpression(), resolution);
@@ -7545,7 +7671,7 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (import_ts_morph32.Node.isCallExpression(written) || import_ts_morph32.Node.isNewExpression(written)) {
+  if (import_ts_morph33.Node.isCallExpression(written) || import_ts_morph33.Node.isNewExpression(written)) {
     return written;
   }
   if (resolution === void 0 || !couldNameAValue(written)) {
@@ -7565,13 +7691,13 @@ function stringValueOf(value, resolution) {
   return resolved !== null && isStringNode(resolved) ? resolved.getLiteralValue() : null;
 }
 function isStringNode(node) {
-  return import_ts_morph32.Node.isStringLiteral(node) || import_ts_morph32.Node.isNoSubstitutionTemplateLiteral(node);
+  return import_ts_morph33.Node.isStringLiteral(node) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(node);
 }
 function arrayLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph32.Node.isArrayLiteralExpression(node)
+    (node) => import_ts_morph33.Node.isArrayLiteralExpression(node)
   );
 }
 function literalValueOf(value, resolution, isWanted) {
@@ -7728,7 +7854,7 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheConstruction === null) {
     return "unknown";
   }
-  if (!import_ts_morph33.Node.isNewExpression(cacheConstruction) && !import_ts_morph33.Node.isCallExpression(cacheConstruction)) {
+  if (!import_ts_morph34.Node.isNewExpression(cacheConstruction) && !import_ts_morph34.Node.isCallExpression(cacheConstruction)) {
     return "unknown";
   }
   const args = cacheConstruction.getArguments();
@@ -7742,15 +7868,15 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheOptions.getProperty(spec.registryProperty) !== void 0) {
     return "configured";
   }
-  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph33.Node.isSpreadAssignment(property));
+  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph34.Node.isSpreadAssignment(property));
   return hasSpread ? "unknown" : "absent";
 }
 function firstArgumentObjectLiteral(construction) {
-  if (!import_ts_morph33.Node.isNewExpression(construction) && !import_ts_morph33.Node.isCallExpression(construction)) {
+  if (!import_ts_morph34.Node.isNewExpression(construction) && !import_ts_morph34.Node.isCallExpression(construction)) {
     return null;
   }
   const arg = construction.getArguments()[0];
-  if (arg === void 0 || !import_ts_morph33.Node.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !import_ts_morph34.Node.isObjectLiteralExpression(arg)) {
     return null;
   }
   return arg;
@@ -7760,10 +7886,10 @@ function propertyValueOf2(options, name) {
   if (property === void 0) {
     return null;
   }
-  if (import_ts_morph33.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph34.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph33.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph34.Node.isShorthandPropertyAssignment(property)) {
     const symbol = property.getProject().getTypeChecker().getShorthandAssignmentValueSymbol(property);
     return symbol?.getValueDeclaration() ?? null;
   }
@@ -7773,13 +7899,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_morph33.Node.isVariableDeclaration(current2)) {
+    if (import_ts_morph34.Node.isVariableDeclaration(current2)) {
       current2 = current2.getInitializer();
       continue;
     }
-    if (import_ts_morph33.Node.isNewExpression(current2) || import_ts_morph33.Node.isCallExpression(current2)) {
+    if (import_ts_morph34.Node.isNewExpression(current2) || import_ts_morph34.Node.isCallExpression(current2)) {
       const callee = current2.getExpression();
-      if (callee === void 0 || !import_ts_morph33.Node.isIdentifier(callee)) {
+      if (callee === void 0 || !import_ts_morph34.Node.isIdentifier(callee)) {
         return null;
       }
       const local = localImportName(
@@ -7789,11 +7915,11 @@ function resolveToConstructionOf(expression, cacheClass) {
       );
       return local !== null && callee.getText() === local ? current2 : null;
     }
-    if (!import_ts_morph33.Node.isIdentifier(current2)) {
+    if (!import_ts_morph34.Node.isIdentifier(current2)) {
       return null;
     }
     const declaration = current2.getSymbol()?.getValueDeclaration();
-    if (declaration === void 0 || !import_ts_morph33.Node.isVariableDeclaration(declaration)) {
+    if (declaration === void 0 || !import_ts_morph34.Node.isVariableDeclaration(declaration)) {
       return null;
     }
     current2 = declaration.getInitializer();
@@ -7802,17 +7928,17 @@ function resolveToConstructionOf(expression, cacheClass) {
 }
 function unwrapExpression2(node) {
   let current2 = node;
-  while (import_ts_morph33.Node.isParenthesizedExpression(current2) || import_ts_morph33.Node.isAsExpression(current2) || import_ts_morph33.Node.isNonNullExpression(current2)) {
+  while (import_ts_morph34.Node.isParenthesizedExpression(current2) || import_ts_morph34.Node.isAsExpression(current2) || import_ts_morph34.Node.isNonNullExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
 }
 function isConstructionNamed(node, localName) {
-  if (!import_ts_morph33.Node.isNewExpression(node) && !import_ts_morph33.Node.isCallExpression(node)) {
+  if (!import_ts_morph34.Node.isNewExpression(node) && !import_ts_morph34.Node.isCallExpression(node)) {
     return false;
   }
   const callee = node.getExpression();
-  return callee !== void 0 && import_ts_morph33.Node.isIdentifier(callee) && callee.getText() === localName;
+  return callee !== void 0 && import_ts_morph34.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function localImportName(sourceFile, importModule, importName) {
   for (const importDecl of sourceFile.getImportDeclarations()) {
@@ -7848,11 +7974,11 @@ function localNamesFor(sourceFile, specs) {
   return names;
 }
 function constructionRef(node, localNames, resolution) {
-  if (!import_ts_morph33.Node.isNewExpression(node) && !import_ts_morph33.Node.isCallExpression(node)) {
+  if (!import_ts_morph34.Node.isNewExpression(node) && !import_ts_morph34.Node.isCallExpression(node)) {
     return null;
   }
   const callee = node.getExpression();
-  if (callee === void 0 || !import_ts_morph33.Node.isIdentifier(callee)) {
+  if (callee === void 0 || !import_ts_morph34.Node.isIdentifier(callee)) {
     return null;
   }
   const uriProperty = localNames.get(callee.getText());
@@ -7860,11 +7986,11 @@ function constructionRef(node, localNames, resolution) {
     return null;
   }
   const optionsArg = node.getArguments()[0];
-  if (optionsArg === void 0 || !import_ts_morph33.Node.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg === void 0 || !import_ts_morph34.Node.isObjectLiteralExpression(optionsArg)) {
     return null;
   }
   const property = optionsArg.getProperty(uriProperty);
-  if (property === void 0 || !import_ts_morph33.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph34.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
@@ -7880,7 +8006,7 @@ function constructionRef(node, localNames, resolution) {
 
 // src/discovery/clientCall.ts
 var import_node_path4 = __toESM(require("path"), 1);
-var import_ts_morph34 = require("ts-morph");
+var import_ts_morph35 = require("ts-morph");
 
 // src/discovery/resolveImport.ts
 function resolveImportedLocalName(sourceFile, importModule, importName) {
@@ -7924,26 +8050,26 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   if (!isGlobal && importedLocalName !== null) {
     for (const varDecl of sourceFile.getVariableDeclarations()) {
       const init = varDecl.getInitializer();
-      if (init !== void 0 && (import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init)) && isInstanceCreationCall(init, importedLocalName, match.factoryMethods)) {
+      if (init !== void 0 && (import_ts_morph35.Node.isCallExpression(init) || import_ts_morph35.Node.isNewExpression(init)) && isInstanceCreationCall(init, importedLocalName, match.factoryMethods)) {
         clientVarNames.add(varDecl.getName());
       }
     }
   }
   const methodFilter = match.methodFilter !== void 0 ? new Set(match.methodFilter) : null;
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
     let methodName = null;
     let matched = false;
-    if (isGlobal && import_ts_morph34.Node.isIdentifier(callee)) {
+    if (isGlobal && import_ts_morph35.Node.isIdentifier(callee)) {
       if (callee.getText() === importedLocalName) {
         matched = true;
       }
-    } else if (import_ts_morph34.Node.isPropertyAccessExpression(callee)) {
+    } else if (import_ts_morph35.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph34.Node.isIdentifier(subject) && (importedLocalName !== null && subject.getText() === importedLocalName || clientVarNames.has(subject.getText()) || resolvesToKnownInstance(subject, match, resolution))) {
+      if (import_ts_morph35.Node.isIdentifier(subject) && (importedLocalName !== null && subject.getText() === importedLocalName || clientVarNames.has(subject.getText()) || resolvesToKnownInstance(subject, match, resolution))) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -7978,16 +8104,16 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
   const constructedHere = /* @__PURE__ */ new Set();
   if (localName !== null) {
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph34.Node.isVariableDeclaration(node)) {
+      if (import_ts_morph35.Node.isVariableDeclaration(node)) {
         const init = node.getInitializer();
-        if (init !== void 0 && (import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init)) && isInstanceCreationCall(init, localName, match.factoryMethods) || typedAsClient(node.getTypeNode(), localName)) {
+        if (init !== void 0 && (import_ts_morph35.Node.isCallExpression(init) || import_ts_morph35.Node.isNewExpression(init)) && isInstanceCreationCall(init, localName, match.factoryMethods) || typedAsClient(node.getTypeNode(), localName)) {
           constructedHere.add(node.getName());
         }
         return;
       }
-      if (import_ts_morph34.Node.isParameterDeclaration(node) && typedAsClient(node.getTypeNode(), localName)) {
+      if (import_ts_morph35.Node.isParameterDeclaration(node) && typedAsClient(node.getTypeNode(), localName)) {
         const written = node.getNameNode();
-        if (import_ts_morph34.Node.isIdentifier(written)) {
+        if (import_ts_morph35.Node.isIdentifier(written)) {
           constructedHere.add(written.getText());
         }
       }
@@ -7999,10 +8125,10 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
     importName: match.importName,
     ...match.factoryMethods === void 0 ? {} : { factoryMethods: match.factoryMethods }
   };
-  return (subject) => localName !== null && import_ts_morph34.Node.isIdentifier(subject) && subject.getText() === localName || import_ts_morph34.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
+  return (subject) => localName !== null && import_ts_morph35.Node.isIdentifier(subject) && subject.getText() === localName || import_ts_morph35.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
 }
 function typedAsClient(typeNode, localName) {
-  if (typeNode === void 0 || !import_ts_morph34.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph35.Node.isTypeReference(typeNode)) {
     return false;
   }
   return typeNode.getTypeName().getText() === localName;
@@ -8012,7 +8138,7 @@ function resolvesToKnownInstance(subject, match, resolution) {
     return false;
   }
   const written = writtenNodeOf(subject, resolution);
-  if (written === null || !import_ts_morph34.Node.isCallExpression(written) && !import_ts_morph34.Node.isNewExpression(written)) {
+  if (written === null || !import_ts_morph35.Node.isCallExpression(written) && !import_ts_morph35.Node.isNewExpression(written)) {
     return false;
   }
   const writtenLocalName = resolvedImportLocalName(
@@ -8093,31 +8219,31 @@ function withoutSourceExtension(filePath) {
   return filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\/index$/, "");
 }
 function clientUnitName(enclosingFunc, methodName) {
-  if (import_ts_morph34.Node.isFunctionDeclaration(enclosingFunc)) {
+  if (import_ts_morph35.Node.isFunctionDeclaration(enclosingFunc)) {
     return enclosingFunc.getName() ?? methodName ?? "anonymous";
   }
-  if (import_ts_morph34.Node.isMethodDeclaration(enclosingFunc)) {
+  if (import_ts_morph35.Node.isMethodDeclaration(enclosingFunc)) {
     return enclosingFunc.getName();
   }
   const parent = enclosingFunc.getParent();
-  if (parent !== void 0 && import_ts_morph34.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph35.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
-  if (parent !== void 0 && import_ts_morph34.Node.isPropertyAssignment(parent)) {
+  if (parent !== void 0 && import_ts_morph35.Node.isPropertyAssignment(parent)) {
     return parent.getName();
   }
   return methodName ?? "anonymous";
 }
 
 // src/discovery/decoratedMethod.ts
-var import_ts_morph37 = require("ts-morph");
+var import_ts_morph38 = require("ts-morph");
 
 // src/discovery/decoratedMembers.ts
-var import_ts_morph35 = require("ts-morph");
+var import_ts_morph36 = require("ts-morph");
 function decoratedCallablesOf(cls, decoratorNames) {
   const callables = [];
   for (const member of cls.getMembers()) {
-    if (!import_ts_morph35.Node.isMethodDeclaration(member) && !import_ts_morph35.Node.isPropertyDeclaration(member)) {
+    if (!import_ts_morph36.Node.isMethodDeclaration(member) && !import_ts_morph36.Node.isPropertyDeclaration(member)) {
       continue;
     }
     const func = callableOf(member);
@@ -8141,7 +8267,7 @@ function decoratedCallablesOf(cls, decoratorNames) {
   return callables;
 }
 function callableOf(member) {
-  if (import_ts_morph35.Node.isMethodDeclaration(member)) {
+  if (import_ts_morph36.Node.isMethodDeclaration(member)) {
     return toFunctionRoot(member);
   }
   const held = member.getInitializer();
@@ -8149,7 +8275,7 @@ function callableOf(member) {
 }
 
 // src/discovery/decoratorComposition.ts
-var import_ts_morph36 = require("ts-morph");
+var import_ts_morph37 = require("ts-morph");
 function classDecoratorStandingFor(cls, names, modules, resolution) {
   for (const candidate of names) {
     const decorator = cls.getDecorator(candidate);
@@ -8187,7 +8313,7 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   if (wrapper === null) {
     return atClass;
   }
-  for (const call of wrapper.getDescendantsOfKind(import_ts_morph36.SyntaxKind.CallExpression)) {
+  for (const call of wrapper.getDescendantsOfKind(import_ts_morph37.SyntaxKind.CallExpression)) {
     const names = resolution.importedNamesOf(call.getExpression(), modules);
     if (!names.includes(standsFor)) {
       continue;
@@ -8198,10 +8324,10 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   return atClass;
 }
 function statesAValue(arg, wrapper) {
-  const identifiers = import_ts_morph36.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph36.SyntaxKind.Identifier);
+  const identifiers = import_ts_morph37.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph37.SyntaxKind.Identifier);
   return !identifiers.some(
     (identifier) => identifier.getSymbol()?.getDeclarations().some(
-      (declaration) => import_ts_morph36.Node.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
+      (declaration) => import_ts_morph37.Node.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
     )
   );
 }
@@ -8221,39 +8347,39 @@ function resolverTypeName(args) {
   return args.typeMap[args.decoratorName] ?? args.classTypeName ?? null;
 }
 function resolveResolverClassTypeName(decoratorArg) {
-  if (import_ts_morph37.Node.isArrowFunction(decoratorArg)) {
+  if (import_ts_morph38.Node.isArrowFunction(decoratorArg)) {
     const body = decoratorArg.getBody();
-    if (import_ts_morph37.Node.isIdentifier(body)) {
+    if (import_ts_morph38.Node.isIdentifier(body)) {
       return body.getText();
     }
     return null;
   }
-  if (import_ts_morph37.Node.isStringLiteral(decoratorArg)) {
+  if (import_ts_morph38.Node.isStringLiteral(decoratorArg)) {
     return decoratorArg.getLiteralValue();
   }
-  if (import_ts_morph37.Node.isIdentifier(decoratorArg)) {
+  if (import_ts_morph38.Node.isIdentifier(decoratorArg)) {
     return decoratorArg.getText();
   }
   return null;
 }
 function resolveOperationNameOverride(decorator) {
-  if (!import_ts_morph37.Node.isDecorator(decorator)) {
+  if (!import_ts_morph38.Node.isDecorator(decorator)) {
     return null;
   }
   const args = decorator.getArguments();
   for (const arg of args) {
-    if (!import_ts_morph37.Node.isObjectLiteralExpression(arg)) {
+    if (!import_ts_morph38.Node.isObjectLiteralExpression(arg)) {
       continue;
     }
     const prop = arg.getProperty("name");
-    if (prop === void 0 || !import_ts_morph37.Node.isPropertyAssignment(prop)) {
+    if (prop === void 0 || !import_ts_morph38.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const init = prop.getInitializer();
     if (init === void 0) {
       continue;
     }
-    if (import_ts_morph37.Node.isStringLiteral(init) || import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(init)) {
+    if (import_ts_morph38.Node.isStringLiteral(init) || import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(init)) {
       return init.getLiteralValue();
     }
   }
@@ -8311,9 +8437,9 @@ function discoverDecoratedMethods(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/decoratedRoute.ts
-var import_ts_morph38 = require("ts-morph");
+var import_ts_morph39 = require("ts-morph");
 function resolveRoutePathArg(decorator, resolution) {
-  if (!import_ts_morph38.Node.isDecorator(decorator)) {
+  if (!import_ts_morph39.Node.isDecorator(decorator)) {
     return "";
   }
   return routePathOf(decorator.getArguments(), resolution);
@@ -8341,7 +8467,7 @@ function declaredChannelOf(source, decorator, resolution) {
   if (source.from === "unstated") {
     return null;
   }
-  if (!import_ts_morph38.Node.isDecorator(decorator)) {
+  if (!import_ts_morph39.Node.isDecorator(decorator)) {
     return null;
   }
   const arg = decorator.getArguments()[source.position];
@@ -8352,7 +8478,7 @@ function declaredChannelOf(source, decorator, resolution) {
   return text === null || text === "" ? null : text;
 }
 function literalStringOf(node, resolution) {
-  if (import_ts_morph38.Node.isStringLiteral(node) || import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph39.Node.isStringLiteral(node) || import_ts_morph39.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   const written = resolution?.resolveWrittenValue(node) ?? null;
@@ -8427,31 +8553,31 @@ function discoverDecoratedRoutes(sourceFile, match, kind, resolution, binding) {
 var import_picomatch2 = __toESM(require("picomatch"), 1);
 
 // src/discovery/namedExport.ts
-var import_ts_morph39 = require("ts-morph");
+var import_ts_morph40 = require("ts-morph");
 function nameWrittenAt(expression) {
-  if (import_ts_morph39.Node.isIdentifier(expression)) {
+  if (import_ts_morph40.Node.isIdentifier(expression)) {
     return expression.getText();
   }
-  if (import_ts_morph39.Node.isPropertyAccessExpression(expression)) {
+  if (import_ts_morph40.Node.isPropertyAccessExpression(expression)) {
     return expression.getName();
   }
   return null;
 }
 function resolveDefaultExportName(decl, fn) {
-  if (import_ts_morph39.Node.isFunctionDeclaration(fn) || import_ts_morph39.Node.isFunctionExpression(fn)) {
+  if (import_ts_morph40.Node.isFunctionDeclaration(fn) || import_ts_morph40.Node.isFunctionExpression(fn)) {
     const n = fn.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph39.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph40.Node.isVariableDeclaration(decl)) {
     const name = decl.getName();
     if (name.length > 0) {
       return name;
     }
   }
   const binding = fn.getParent();
-  if (binding !== void 0 && import_ts_morph39.Node.isVariableDeclaration(binding)) {
+  if (binding !== void 0 && import_ts_morph40.Node.isVariableDeclaration(binding)) {
     const name = binding.getName();
     if (name.length > 0) {
       return name;
@@ -8506,7 +8632,7 @@ function discoverNamedExports(sourceFile, match, kind, resolution) {
       }
       continue;
     }
-    if (import_ts_morph39.Node.isArrowFunction(init) || import_ts_morph39.Node.isFunctionExpression(init)) {
+    if (import_ts_morph40.Node.isArrowFunction(init) || import_ts_morph40.Node.isFunctionExpression(init)) {
       results.push({
         func: init,
         kind,
@@ -8612,13 +8738,13 @@ function discoverFileConventions(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlHookCall.ts
-var import_ts_morph41 = require("ts-morph");
+var import_ts_morph42 = require("ts-morph");
 
 // src/discovery/graphqlShared.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
 var import_graphql = require("graphql");
-var import_ts_morph40 = require("ts-morph");
+var import_ts_morph41 = require("ts-morph");
 var DOCUMENT_TAGS = /* @__PURE__ */ new Set(["gql", "graphql"]);
 var UNQUALIFIED_DOCUMENT_TAG = "gql";
 function parseGraphqlOperation(source) {
@@ -8684,10 +8810,10 @@ function startAssembly(resolution) {
   };
 }
 function assembledTemplateText(template, assembly) {
-  if (import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(template)) {
+  if (import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(template)) {
     return innerTemplateText(template);
   }
-  if (!import_ts_morph40.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph41.Node.isTemplateExpression(template)) {
     return null;
   }
   let text = template.getHead().getLiteralText();
@@ -8823,7 +8949,7 @@ function collectDanglingSpreads(selectionSet, defined, dangling) {
   }
 }
 function documentTextFromExpression(node, assembly) {
-  if (import_ts_morph40.Node.isTaggedTemplateExpression(node)) {
+  if (import_ts_morph41.Node.isTaggedTemplateExpression(node)) {
     if (!isDocumentTag(node.getTag())) {
       return null;
     }
@@ -8833,7 +8959,7 @@ function documentTextFromExpression(node, assembly) {
     assembly.seen.add(node);
     return assembledTemplateText(node.getTemplate(), assembly);
   }
-  if (!import_ts_morph40.Node.isCallExpression(node)) {
+  if (!import_ts_morph41.Node.isCallExpression(node)) {
     return null;
   }
   if (!isDocumentTag(node.getExpression())) {
@@ -8844,7 +8970,7 @@ function documentTextFromExpression(node, assembly) {
     return null;
   }
   const template = stripDocumentNodeCasts(first);
-  if (!import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph40.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph41.Node.isTemplateExpression(template)) {
     return null;
   }
   if (assembly.seen.has(node)) {
@@ -8854,7 +8980,7 @@ function documentTextFromExpression(node, assembly) {
   return assembledTemplateText(template, assembly);
 }
 function isDocumentTag(tag) {
-  if (!import_ts_morph40.Node.isIdentifier(tag)) {
+  if (!import_ts_morph41.Node.isIdentifier(tag)) {
     return false;
   }
   if (tag.getText() === UNQUALIFIED_DOCUMENT_TAG) {
@@ -8865,14 +8991,14 @@ function isDocumentTag(tag) {
     return false;
   }
   for (const declaration of symbol.getDeclarations()) {
-    if (import_ts_morph40.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
+    if (import_ts_morph41.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
       return true;
     }
   }
   return false;
 }
 function resolveThroughFacts(arg, assembly) {
-  if (assembly.resolution === void 0 || !import_ts_morph40.Node.isIdentifier(arg)) {
+  if (assembly.resolution === void 0 || !import_ts_morph41.Node.isIdentifier(arg)) {
     return null;
   }
   const written = assembly.resolution.resolveWrittenValue(arg);
@@ -8921,7 +9047,7 @@ function singleLine(text) {
   return collapsed.length > 80 ? `${collapsed.slice(0, 79)}\u2026` : collapsed;
 }
 function importedVariableInitializers(identifier) {
-  if (!import_ts_morph40.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph41.Node.isIdentifier(identifier)) {
     return [];
   }
   const symbol = identifier.getSymbol();
@@ -8931,7 +9057,7 @@ function importedVariableInitializers(identifier) {
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   const inits = [];
   for (const decl of resolved.getDeclarations()) {
-    if (import_ts_morph40.Node.isVariableDeclaration(decl)) {
+    if (import_ts_morph41.Node.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
       if (init !== void 0) {
         inits.push(init);
@@ -8945,7 +9071,7 @@ function resolveGqlTemplateText(arg, assembly) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph40.Node.isIdentifier(arg)) {
+  if (!import_ts_morph41.Node.isIdentifier(arg)) {
     return null;
   }
   const symbol = arg.getSymbol();
@@ -8953,7 +9079,7 @@ function resolveGqlTemplateText(arg, assembly) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (import_ts_morph40.Node.isImportClause(decl) || import_ts_morph40.Node.isImportSpecifier(decl)) {
+    if (import_ts_morph41.Node.isImportClause(decl) || import_ts_morph41.Node.isImportSpecifier(decl)) {
       const fromGraphqlFile = resolveGraphqlFileImport(decl);
       if (fromGraphqlFile !== null) {
         return fromGraphqlFile;
@@ -8972,7 +9098,7 @@ function resolveGqlTemplateText(arg, assembly) {
   return null;
 }
 function resolveTypedDocumentSource(arg) {
-  if (!import_ts_morph40.Node.isIdentifier(arg)) {
+  if (!import_ts_morph41.Node.isIdentifier(arg)) {
     return null;
   }
   for (const init of importedVariableInitializers(arg)) {
@@ -8985,7 +9111,7 @@ function resolveTypedDocumentSource(arg) {
 }
 function typedDocumentSourceOf(node) {
   const inner = stripDocumentNodeCasts(node);
-  if (!import_ts_morph40.Node.isObjectLiteralExpression(inner)) {
+  if (!import_ts_morph41.Node.isObjectLiteralExpression(inner)) {
     return null;
   }
   const evaluated = evaluateObjectLiteralAsJson(inner);
@@ -9003,7 +9129,7 @@ function typedDocumentSourceOf(node) {
   }
 }
 function resolveTypedDocumentHeader(arg) {
-  if (!import_ts_morph40.Node.isIdentifier(arg)) {
+  if (!import_ts_morph41.Node.isIdentifier(arg)) {
     return null;
   }
   const reference = arg.getText();
@@ -9013,7 +9139,7 @@ function resolveTypedDocumentHeader(arg) {
   }
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   for (const decl of resolved.getDeclarations()) {
-    if (!import_ts_morph40.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph41.Node.isVariableDeclaration(decl)) {
       continue;
     }
     const init = decl.getInitializer();
@@ -9046,10 +9172,10 @@ function resolveTypedDocumentHeader(arg) {
 }
 function documentNodeCastTypeArgs(node) {
   let current2 = node;
-  while (import_ts_morph40.Node.isAsExpression(current2) || import_ts_morph40.Node.isParenthesizedExpression(current2)) {
-    if (import_ts_morph40.Node.isAsExpression(current2)) {
+  while (import_ts_morph41.Node.isAsExpression(current2) || import_ts_morph41.Node.isParenthesizedExpression(current2)) {
+    if (import_ts_morph41.Node.isAsExpression(current2)) {
       const typeNode = current2.getTypeNode();
-      if (typeNode !== void 0 && import_ts_morph40.Node.isTypeReference(typeNode)) {
+      if (typeNode !== void 0 && import_ts_morph41.Node.isTypeReference(typeNode)) {
         const name = typeNode.getTypeName().getText();
         const simpleName = name.includes(".") ? name.split(".").pop() ?? name : name;
         if (simpleName === "TypedDocumentNode" || simpleName === "DocumentNode") {
@@ -9062,7 +9188,7 @@ function documentNodeCastTypeArgs(node) {
   return null;
 }
 function operationHeaderFromResultType(typeNode) {
-  if (typeNode === void 0 || !import_ts_morph40.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph41.Node.isTypeReference(typeNode)) {
     return null;
   }
   const name = typeNode.getTypeName().getText();
@@ -9083,16 +9209,16 @@ function operationHeaderFromResultType(typeNode) {
 }
 function stripDocumentNodeCasts(node) {
   let current2 = node;
-  while (import_ts_morph40.Node.isAsExpression(current2) || import_ts_morph40.Node.isParenthesizedExpression(current2)) {
+  while (import_ts_morph41.Node.isAsExpression(current2) || import_ts_morph41.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
 }
 function evaluateObjectLiteralAsJson(node) {
-  if (import_ts_morph40.Node.isStringLiteral(node) || import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph41.Node.isStringLiteral(node) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
-  if (import_ts_morph40.Node.isNumericLiteral(node)) {
+  if (import_ts_morph41.Node.isNumericLiteral(node)) {
     return Number(node.getText());
   }
   const kind = node.getText();
@@ -9105,17 +9231,17 @@ function evaluateObjectLiteralAsJson(node) {
   if (kind === "null") {
     return null;
   }
-  if (import_ts_morph40.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph41.Node.isObjectLiteralExpression(node)) {
     const out = {};
     for (const prop of node.getProperties()) {
-      if (!import_ts_morph40.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph41.Node.isPropertyAssignment(prop)) {
         return null;
       }
       const nameNode = prop.getNameNode();
       let name;
-      if (import_ts_morph40.Node.isIdentifier(nameNode)) {
+      if (import_ts_morph41.Node.isIdentifier(nameNode)) {
         name = nameNode.getText();
-      } else if (import_ts_morph40.Node.isStringLiteral(nameNode) || import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
+      } else if (import_ts_morph41.Node.isStringLiteral(nameNode) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
         name = nameNode.getLiteralValue();
       } else {
         return null;
@@ -9132,7 +9258,7 @@ function evaluateObjectLiteralAsJson(node) {
     }
     return out;
   }
-  if (import_ts_morph40.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph41.Node.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.getElements()) {
       const value = evaluateObjectLiteralAsJson(el);
@@ -9146,8 +9272,8 @@ function evaluateObjectLiteralAsJson(node) {
   return void 0;
 }
 function resolveGraphqlFileImport(decl) {
-  const importDecl = import_ts_morph40.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph40.Node.isImportClause(decl) ? decl.getParent() : null;
-  if (importDecl === null || importDecl === void 0 || !import_ts_morph40.Node.isImportDeclaration(importDecl)) {
+  const importDecl = import_ts_morph41.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph41.Node.isImportClause(decl) ? decl.getParent() : null;
+  if (importDecl === null || importDecl === void 0 || !import_ts_morph41.Node.isImportDeclaration(importDecl)) {
     return null;
   }
   const specifier = importDecl.getModuleSpecifierValue();
@@ -9166,7 +9292,7 @@ function resolveGraphqlFileImport(decl) {
 function enclosingFunctionRoot(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph40.Node.isFunctionDeclaration(current2) || import_ts_morph40.Node.isFunctionExpression(current2) || import_ts_morph40.Node.isArrowFunction(current2) || import_ts_morph40.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph41.Node.isFunctionDeclaration(current2) || import_ts_morph41.Node.isFunctionExpression(current2) || import_ts_morph41.Node.isArrowFunction(current2) || import_ts_morph41.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -9174,11 +9300,11 @@ function enclosingFunctionRoot(node) {
   return null;
 }
 function functionNameOrAnon(func) {
-  if (import_ts_morph40.Node.isFunctionDeclaration(func) || import_ts_morph40.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph41.Node.isFunctionDeclaration(func) || import_ts_morph41.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "<anon>";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph40.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph41.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return "<anon>";
@@ -9209,11 +9335,11 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph41.Node.isCallExpression(node)) {
+    if (!import_ts_morph42.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph41.Node.isIdentifier(callee)) {
+    if (!import_ts_morph42.Node.isIdentifier(callee)) {
       return;
     }
     const spec = hookByLocal.get(callee.getText());
@@ -9249,7 +9375,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlImperativeCall.ts
-var import_ts_morph42 = require("ts-morph");
+var import_ts_morph43 = require("ts-morph");
 function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   const isTheClient = clientReceiverCheckFor(sourceFile, match, resolution);
   const methodSpec = /* @__PURE__ */ new Map();
@@ -9261,11 +9387,11 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph42.Node.isCallExpression(node)) {
+    if (!import_ts_morph43.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph42.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph43.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -9277,7 +9403,7 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph42.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph43.Node.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -9313,16 +9439,16 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   return results;
 }
 function imperativeConfigValue(prop) {
-  if (import_ts_morph42.Node.isPropertyAssignment(prop)) {
+  if (import_ts_morph43.Node.isPropertyAssignment(prop)) {
     return prop.getInitializer() ?? null;
   }
-  if (import_ts_morph42.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph43.Node.isShorthandPropertyAssignment(prop)) {
     const valueSymbol = prop.getValueSymbol();
     if (valueSymbol === void 0) {
       return null;
     }
     for (const decl of valueSymbol.getDeclarations()) {
-      if (import_ts_morph42.Node.isVariableDeclaration(decl)) {
+      if (import_ts_morph43.Node.isVariableDeclaration(decl)) {
         const init = decl.getInitializer();
         if (init !== void 0) {
           return init;
@@ -9335,7 +9461,7 @@ function imperativeConfigValue(prop) {
 }
 
 // src/discovery/jsxElementRoute.ts
-var import_ts_morph43 = require("ts-morph");
+var import_ts_morph44 = require("ts-morph");
 var PATH_NOT_LITERAL = "The path this route declares is not written as a string literal, so no path is claimed and this route pairs with nothing";
 var ENCLOSING_PATH_NOT_LITERAL = "A route this one is nested under declares its path as something other than a string literal, so the full path is not claimed and this route pairs with nothing";
 var SPREAD_NOT_ENUMERATED = "A spread stands in for routes declared elsewhere in this array, and they are not read here, so no path is claimed for any of them";
@@ -9367,7 +9493,7 @@ function discoverJsxElementRoutes(sourceFile, match, kind, resolution) {
       }
       return;
     }
-    if (import_ts_morph43.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
+    if (import_ts_morph44.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
       results.push(
         ...unitsForRouteArray(node, match, elementsNames, kind, resolution)
       );
@@ -9394,7 +9520,7 @@ function localNamesFor2(sourceFile, match, exported) {
   return local;
 }
 function asRouteJsx(node, routeNames) {
-  if (!import_ts_morph43.Node.isJsxSelfClosingElement(node) && !import_ts_morph43.Node.isJsxElement(node)) {
+  if (!import_ts_morph44.Node.isJsxSelfClosingElement(node) && !import_ts_morph44.Node.isJsxElement(node)) {
     return null;
   }
   return isRouteJsx(node, routeNames) ? node : null;
@@ -9404,15 +9530,15 @@ function isRouteJsx(node, routeNames) {
   return tag !== null && routeNames.has(tag.getText());
 }
 function tagNameOf(node) {
-  const tag = import_ts_morph43.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
-  return import_ts_morph43.Node.isIdentifier(tag) ? tag : null;
+  const tag = import_ts_morph44.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
+  return import_ts_morph44.Node.isIdentifier(tag) ? tag : null;
 }
 function attributesOf(node) {
-  return import_ts_morph43.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
+  return import_ts_morph44.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
 }
 function attributeValueOf(node, name) {
   for (const attribute of attributesOf(node)) {
-    if (!import_ts_morph43.Node.isJsxAttribute(attribute)) {
+    if (!import_ts_morph44.Node.isJsxAttribute(attribute)) {
       continue;
     }
     if (attribute.getNameNode().getText() !== name) {
@@ -9423,8 +9549,8 @@ function attributeValueOf(node, name) {
   return null;
 }
 function literalStringOf2(value) {
-  const unwrapped2 = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (import_ts_morph43.Node.isStringLiteral(unwrapped2) || import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  const unwrapped2 = import_ts_morph44.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (import_ts_morph44.Node.isStringLiteral(unwrapped2) || import_ts_morph44.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return unwrapped2.getLiteralValue();
   }
   return null;
@@ -9444,8 +9570,8 @@ function elementTargetOfValue(value) {
   if (value === null) {
     return { kind: "absent" };
   }
-  const unwrapped2 = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (!import_ts_morph43.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph43.Node.isJsxElement(unwrapped2)) {
+  const unwrapped2 = import_ts_morph44.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (!import_ts_morph44.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph44.Node.isJsxElement(unwrapped2)) {
     return { kind: "unreadable" };
   }
   const tag = tagNameOf(unwrapped2);
@@ -9457,7 +9583,7 @@ function elementTargetOfValue(value) {
 function composedPrefixOf(node, match, routeNames) {
   const enclosing = [];
   for (const ancestor of node.getAncestors()) {
-    if (import_ts_morph43.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
+    if (import_ts_morph44.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
       enclosing.push(ancestor);
     }
   }
@@ -9573,14 +9699,14 @@ function abstention(at, kind, sentence, label) {
 }
 function callsAFactory(call, factoryNames) {
   const callee = call.getExpression();
-  return import_ts_morph43.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
+  return import_ts_morph44.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
 }
 function unitsForRouteArray(call, match, elementsNames, kind, resolution) {
   const first = call.getArguments()[0];
   if (first === void 0) {
     return [];
   }
-  if (import_ts_morph43.Node.isJsxElement(first) || import_ts_morph43.Node.isJsxSelfClosingElement(first) || import_ts_morph43.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
+  if (import_ts_morph44.Node.isJsxElement(first) || import_ts_morph44.Node.isJsxSelfClosingElement(first) || import_ts_morph44.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
     return [];
   }
   const array = arrayLiteralOf(first, resolution);
@@ -9605,7 +9731,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
   const nestedIn = new Set(ancestry).add(array);
   const results = [];
   for (const element of array.getElements()) {
-    if (import_ts_morph43.Node.isSpreadElement(element)) {
+    if (import_ts_morph44.Node.isSpreadElement(element)) {
       results.push(
         abstention(
           element,
@@ -9616,7 +9742,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
       );
       continue;
     }
-    if (!import_ts_morph43.Node.isObjectLiteralExpression(element)) {
+    if (!import_ts_morph44.Node.isObjectLiteralExpression(element)) {
       results.push(
         abstention(
           element,
@@ -9705,7 +9831,7 @@ function ownPathOfObject(object, match) {
   }
   if (match.indexAttribute !== void 0) {
     const indexValue = routePropertyOf(object, match.indexAttribute);
-    if (indexValue !== null && import_ts_morph43.Node.isTrueLiteral(indexValue)) {
+    if (indexValue !== null && import_ts_morph44.Node.isTrueLiteral(indexValue)) {
       return { kind: "inherited" };
     }
   }
@@ -9719,10 +9845,10 @@ function objectLabelOf(target) {
   return target.kind === "named" ? target.identifier.getText() : "declaration";
 }
 function labelOfExpression(node) {
-  if (import_ts_morph43.Node.isIdentifier(node)) {
+  if (import_ts_morph44.Node.isIdentifier(node)) {
     return node.getText();
   }
-  if (import_ts_morph43.Node.isCallExpression(node)) {
+  if (import_ts_morph44.Node.isCallExpression(node)) {
     return node.getExpression().getText();
   }
   return node.getKindName();
@@ -9730,7 +9856,7 @@ function labelOfExpression(node) {
 
 // src/discovery/packageExports.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
-var import_ts_morph45 = require("ts-morph");
+var import_ts_morph46 = require("ts-morph");
 
 // src/packageExports.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -9828,12 +9954,12 @@ function resolveSourceFor(pkgDir, distPath, srcRoot) {
 }
 
 // src/discovery/factorySurface.ts
-var import_ts_morph44 = require("ts-morph");
+var import_ts_morph45 = require("ts-morph");
 function surfaceMethods(decl) {
-  if (import_ts_morph44.Node.isClassDeclaration(decl)) {
+  if (import_ts_morph45.Node.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
   }
-  if (import_ts_morph44.Node.isFunctionDeclaration(decl) || import_ts_morph44.Node.isFunctionExpression(decl) || import_ts_morph44.Node.isArrowFunction(decl) || import_ts_morph44.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph45.Node.isFunctionDeclaration(decl) || import_ts_morph45.Node.isFunctionExpression(decl) || import_ts_morph45.Node.isArrowFunction(decl) || import_ts_morph45.Node.isMethodDeclaration(decl)) {
     return surfaceFactoryReturnMethods(decl);
   }
   return [];
@@ -9842,7 +9968,7 @@ function surfaceClassMethods(cls) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const method of cls.getInstanceMethods()) {
-    if (method.hasModifier(import_ts_morph44.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph45.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -9853,7 +9979,7 @@ function surfaceClassMethods(cls) {
     out.push({ func: method, name });
   }
   for (const method of cls.getStaticMethods()) {
-    if (method.hasModifier(import_ts_morph44.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph45.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -9868,9 +9994,9 @@ function surfaceClassMethods(cls) {
 function surfaceFactoryReturnMethods(fn) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  if (import_ts_morph44.Node.isArrowFunction(fn)) {
+  if (import_ts_morph45.Node.isArrowFunction(fn)) {
     const body2 = fn.getBody();
-    if (import_ts_morph44.Node.isExpression(body2)) {
+    if (import_ts_morph45.Node.isExpression(body2)) {
       collectFromObjectLiteral(body2, out, seen);
       return out;
     }
@@ -9881,11 +10007,11 @@ function surfaceFactoryReturnMethods(fn) {
   }
   const returns = [];
   body.forEachDescendant((node, traversal) => {
-    if (import_ts_morph44.Node.isFunctionDeclaration(node) || import_ts_morph44.Node.isFunctionExpression(node) || import_ts_morph44.Node.isArrowFunction(node) || import_ts_morph44.Node.isMethodDeclaration(node) || import_ts_morph44.Node.isConstructorDeclaration(node) || import_ts_morph44.Node.isGetAccessorDeclaration(node) || import_ts_morph44.Node.isSetAccessorDeclaration(node)) {
+    if (import_ts_morph45.Node.isFunctionDeclaration(node) || import_ts_morph45.Node.isFunctionExpression(node) || import_ts_morph45.Node.isArrowFunction(node) || import_ts_morph45.Node.isMethodDeclaration(node) || import_ts_morph45.Node.isConstructorDeclaration(node) || import_ts_morph45.Node.isGetAccessorDeclaration(node) || import_ts_morph45.Node.isSetAccessorDeclaration(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph44.Node.isReturnStatement(node)) {
+    if (import_ts_morph45.Node.isReturnStatement(node)) {
       returns.push(node);
     }
   });
@@ -9900,14 +10026,14 @@ function surfaceFactoryReturnMethods(fn) {
 }
 function collectFromObjectLiteral(node, out, seen) {
   let e = node;
-  while (import_ts_morph44.Node.isParenthesizedExpression(e)) {
+  while (import_ts_morph45.Node.isParenthesizedExpression(e)) {
     e = e.getExpression();
   }
-  if (!import_ts_morph44.Node.isObjectLiteralExpression(e)) {
+  if (!import_ts_morph45.Node.isObjectLiteralExpression(e)) {
     return;
   }
   for (const prop of e.getProperties()) {
-    if (import_ts_morph44.Node.isMethodDeclaration(prop)) {
+    if (import_ts_morph45.Node.isMethodDeclaration(prop)) {
       const name = prop.getName();
       if (seen.has(name)) {
         continue;
@@ -9916,16 +10042,16 @@ function collectFromObjectLiteral(node, out, seen) {
       out.push({ func: prop, name });
       continue;
     }
-    if (import_ts_morph44.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph45.Node.isPropertyAssignment(prop)) {
       const init = prop.getInitializer();
       if (init === void 0) {
         continue;
       }
       let v3 = init;
-      while (import_ts_morph44.Node.isParenthesizedExpression(v3)) {
+      while (import_ts_morph45.Node.isParenthesizedExpression(v3)) {
         v3 = v3.getExpression();
       }
-      if (import_ts_morph44.Node.isArrowFunction(v3) || import_ts_morph44.Node.isFunctionExpression(v3)) {
+      if (import_ts_morph45.Node.isArrowFunction(v3) || import_ts_morph45.Node.isFunctionExpression(v3)) {
         const name = prop.getName();
         if (seen.has(name)) {
           continue;
@@ -9991,9 +10117,9 @@ function discoverPackageExports(sourceFile, match, kind) {
         continue;
       }
       for (const decl of decls) {
-        if (import_ts_morph45.Node.isVariableDeclaration(decl)) {
+        if (import_ts_morph46.Node.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
-          if (init !== void 0 && (import_ts_morph45.Node.isArrowFunction(init) || import_ts_morph45.Node.isFunctionExpression(init))) {
+          if (init !== void 0 && (import_ts_morph46.Node.isArrowFunction(init) || import_ts_morph46.Node.isFunctionExpression(init))) {
             results.push(buildUnit(init, kind, exportName, entry));
             for (const m of surfaceMethods(init)) {
               results.push(buildSurfacedUnit(m, kind, exportName, entry));
@@ -10003,7 +10129,7 @@ function discoverPackageExports(sourceFile, match, kind) {
           }
           continue;
         }
-        if (import_ts_morph45.Node.isClassDeclaration(decl)) {
+        if (import_ts_morph46.Node.isClassDeclaration(decl)) {
           for (const m of surfaceMethods(decl)) {
             results.push(buildSurfacedUnit(m, kind, exportName, entry));
           }
@@ -10048,12 +10174,12 @@ function buildSurfacedUnit(m, kind, parentExportName, entry) {
 }
 
 // src/discovery/packageImport.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph48 = require("ts-morph");
 
 // src/discovery/factoryTracking.ts
-var import_ts_morph46 = require("ts-morph");
+var import_ts_morph47 = require("ts-morph");
 function isScopeNode(node) {
-  return import_ts_morph46.Node.isFunctionDeclaration(node) || import_ts_morph46.Node.isFunctionExpression(node) || import_ts_morph46.Node.isArrowFunction(node) || import_ts_morph46.Node.isMethodDeclaration(node) || import_ts_morph46.Node.isConstructorDeclaration(node) || import_ts_morph46.Node.isGetAccessorDeclaration(node) || import_ts_morph46.Node.isSetAccessorDeclaration(node);
+  return import_ts_morph47.Node.isFunctionDeclaration(node) || import_ts_morph47.Node.isFunctionExpression(node) || import_ts_morph47.Node.isArrowFunction(node) || import_ts_morph47.Node.isMethodDeclaration(node) || import_ts_morph47.Node.isConstructorDeclaration(node) || import_ts_morph47.Node.isGetAccessorDeclaration(node) || import_ts_morph47.Node.isSetAccessorDeclaration(node);
 }
 function trackFactoryBindings(sourceFile, recognize) {
   const scopes = /* @__PURE__ */ new Map();
@@ -10076,19 +10202,19 @@ function trackFactoryBindings(sourceFile, recognize) {
     map.set(name, provenance);
   }
   for (const varDecl of sourceFile.getDescendantsOfKind(
-    import_ts_morph46.SyntaxKind.VariableDeclaration
+    import_ts_morph47.SyntaxKind.VariableDeclaration
   )) {
     const init = varDecl.getInitializer();
     if (init === void 0) {
       continue;
     }
-    const peeled = import_ts_morph46.Node.isAwaitExpression(init) ? init.getExpression() : init;
+    const peeled = import_ts_morph47.Node.isAwaitExpression(init) ? init.getExpression() : init;
     let callee;
     let isNew;
-    if (import_ts_morph46.Node.isCallExpression(peeled)) {
+    if (import_ts_morph47.Node.isCallExpression(peeled)) {
       callee = peeled.getExpression();
       isNew = false;
-    } else if (import_ts_morph46.Node.isNewExpression(peeled)) {
+    } else if (import_ts_morph47.Node.isNewExpression(peeled)) {
       const expr = peeled.getExpression();
       if (expr === void 0) {
         continue;
@@ -10104,11 +10230,11 @@ function trackFactoryBindings(sourceFile, recognize) {
     }
     const scope = scopeOf(varDecl);
     const nameNode = varDecl.getNameNode();
-    if (import_ts_morph46.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph47.Node.isIdentifier(nameNode)) {
       record(scope, nameNode.getText(), provenance);
       continue;
     }
-    if (import_ts_morph46.Node.isObjectBindingPattern(nameNode)) {
+    if (import_ts_morph47.Node.isObjectBindingPattern(nameNode)) {
       for (const elem of nameNode.getElements()) {
         if (elem.getDotDotDotToken() !== void 0) {
           continue;
@@ -10162,13 +10288,13 @@ function splitPackageSpec(spec) {
   };
 }
 function enclosingFunctionName(func) {
-  if (import_ts_morph47.Node.isFunctionDeclaration(func) || import_ts_morph47.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph48.Node.isFunctionDeclaration(func) || import_ts_morph48.Node.isMethodDeclaration(func)) {
     const n = func.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph47.Node.isFunctionExpression(func)) {
+  if (import_ts_morph48.Node.isFunctionExpression(func)) {
     const n = func.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
@@ -10176,10 +10302,10 @@ function enclosingFunctionName(func) {
   }
   const parent = func.getParent();
   if (parent !== void 0) {
-    if (import_ts_morph47.Node.isVariableDeclaration(parent)) {
+    if (import_ts_morph48.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
-    if (import_ts_morph47.Node.isPropertyAssignment(parent)) {
+    if (import_ts_morph48.Node.isPropertyAssignment(parent)) {
       return parent.getName();
     }
   }
@@ -10214,37 +10340,37 @@ function discoverPackageImports(sourceFile, match, kind) {
     return [];
   }
   const trackedBindings = trackFactoryBindings(sourceFile, (callee) => {
-    if (!import_ts_morph47.Node.isIdentifier(callee)) {
+    if (!import_ts_morph48.Node.isIdentifier(callee)) {
       return null;
     }
     return localToExport.get(callee.getText()) ?? null;
   });
   function resolveReceiverProvenance(node, fromNode) {
     let n = node;
-    while (import_ts_morph47.Node.isParenthesizedExpression(n)) {
+    while (import_ts_morph48.Node.isParenthesizedExpression(n)) {
       n = n.getExpression();
     }
-    if (import_ts_morph47.Node.isAwaitExpression(n)) {
+    if (import_ts_morph48.Node.isAwaitExpression(n)) {
       const inner = n.getExpression();
       if (inner === void 0) {
         return null;
       }
       n = inner;
     }
-    if (import_ts_morph47.Node.isIdentifier(n)) {
+    if (import_ts_morph48.Node.isIdentifier(n)) {
       const text = n.getText();
       return trackedBindings.resolve(text, fromNode) ?? localToExport.get(text) ?? null;
     }
-    if (import_ts_morph47.Node.isCallExpression(n)) {
+    if (import_ts_morph48.Node.isCallExpression(n)) {
       const callee = n.getExpression();
-      if (import_ts_morph47.Node.isIdentifier(callee)) {
+      if (import_ts_morph48.Node.isIdentifier(callee)) {
         return localToExport.get(callee.getText()) ?? null;
       }
       return null;
     }
-    if (import_ts_morph47.Node.isNewExpression(n)) {
+    if (import_ts_morph48.Node.isNewExpression(n)) {
       const expr = n.getExpression();
-      if (expr !== void 0 && import_ts_morph47.Node.isIdentifier(expr)) {
+      if (expr !== void 0 && import_ts_morph48.Node.isIdentifier(expr)) {
         return localToExport.get(expr.getText()) ?? null;
       }
       return null;
@@ -10252,11 +10378,11 @@ function discoverPackageImports(sourceFile, match, kind) {
     return null;
   }
   function attributeCall(callee) {
-    if (import_ts_morph47.Node.isIdentifier(callee)) {
+    if (import_ts_morph48.Node.isIdentifier(callee)) {
       const text = callee.getText();
       return trackedBindings.resolve(text, callee) ?? localToExport.get(text) ?? null;
     }
-    if (import_ts_morph47.Node.isPropertyAccessExpression(callee)) {
+    if (import_ts_morph48.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
       const subjectProvenance = resolveReceiverProvenance(subject, callee);
       if (subjectProvenance === null) {
@@ -10284,7 +10410,7 @@ function discoverPackageImports(sourceFile, match, kind) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph47.Node.isCallExpression(node)) {
+    if (!import_ts_morph48.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
@@ -10315,10 +10441,10 @@ function discoverPackageImports(sourceFile, match, kind) {
 }
 
 // src/discovery/registrationCall.ts
-var import_ts_morph49 = require("ts-morph");
+var import_ts_morph50 = require("ts-morph");
 
 // src/resolve/routePath.ts
-var import_ts_morph48 = require("ts-morph");
+var import_ts_morph49 = require("ts-morph");
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
 var URL_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//;
 var URL_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
@@ -10412,26 +10538,26 @@ function pathFromTemplateUrl(arg, resolution) {
   return path13 === "" ? void 0 : path13;
 }
 function pathFromUrlNode(node, resolution) {
-  if (import_ts_morph48.Node.isStringLiteral(node)) {
+  if (import_ts_morph49.Node.isStringLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph48.Node.isTemplateExpression(node)) {
+  if (import_ts_morph49.Node.isTemplateExpression(node)) {
     return pathFromTemplateUrl(node, resolution);
   }
-  if (import_ts_morph48.Node.isBinaryExpression(node)) {
+  if (import_ts_morph49.Node.isBinaryExpression(node)) {
     const joined = joinedStringOf(node, resolution);
     return joined === void 0 ? void 0 : pathFromLiteralUrl(joined);
   }
   return void 0;
 }
 function joinedStringOf(node, resolution) {
-  if (import_ts_morph48.Node.isStringLiteral(node) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph49.Node.isStringLiteral(node) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
-  if (import_ts_morph48.Node.isBinaryExpression(node) && node.getOperatorToken().getText() === "+") {
+  if (import_ts_morph49.Node.isBinaryExpression(node) && node.getOperatorToken().getText() === "+") {
     const left = joinedStringOf(node.getLeft(), resolution);
     const right = joinedStringOf(node.getRight(), resolution);
     return left === void 0 || right === void 0 ? void 0 : left + right;
@@ -10440,10 +10566,10 @@ function joinedStringOf(node, resolution) {
   return written === null || written === node ? void 0 : joinedStringOf(written, resolution);
 }
 function placeholderName(expr) {
-  if (import_ts_morph48.Node.isIdentifier(expr)) {
+  if (import_ts_morph49.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph48.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph49.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return "param";
@@ -10459,7 +10585,7 @@ function holeText(expr, resolution) {
   return pathFromUrlNode(written, resolution) ?? (0, import_behavioral_ir5.patternHole)(placeholderName(expr));
 }
 function emptyStringLiteral(node) {
-  return (import_ts_morph48.Node.isStringLiteral(node) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralValue() === "";
+  return (import_ts_morph49.Node.isStringLiteral(node) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralValue() === "";
 }
 function pathFromArgument(arg, resolution) {
   const written = pathFromUrlNode(arg, resolution);
@@ -10485,11 +10611,11 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     (c) => c.startsWith(".") ? c.slice(1) : c
   );
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph49.Node.isCallExpression(node)) {
+    if (!import_ts_morph50.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph49.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph50.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -10497,7 +10623,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
       return;
     }
     const subject = callee.getExpression();
-    const subjectName = import_ts_morph49.Node.isIdentifier(subject) ? subject.getText() : null;
+    const subjectName = import_ts_morph50.Node.isIdentifier(subject) ? subject.getText() : null;
     const subjectNode = subjectName === null ? void 0 : registrationSubjects.get(subjectName);
     if (subjectNode === void 0) {
       return;
@@ -10505,12 +10631,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     const args = node.getArguments();
     let foundObjectArg = false;
     for (const arg of args) {
-      if (!import_ts_morph49.Node.isObjectLiteralExpression(arg)) {
+      if (!import_ts_morph50.Node.isObjectLiteralExpression(arg)) {
         continue;
       }
       foundObjectArg = true;
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph49.Node.isMethodDeclaration(prop)) {
+        if (import_ts_morph50.Node.isMethodDeclaration(prop)) {
           results.push({
             func: prop,
             kind,
@@ -10518,7 +10644,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           });
           continue;
         }
-        if (!import_ts_morph49.Node.isPropertyAssignment(prop)) {
+        if (!import_ts_morph50.Node.isPropertyAssignment(prop)) {
           continue;
         }
         const propInit = prop.getInitializer();
@@ -10616,9 +10742,9 @@ function registrationSubjectsOf(sourceFile, importModule, importName) {
       continue;
     }
     let calleeText = null;
-    if (import_ts_morph49.Node.isCallExpression(init)) {
+    if (import_ts_morph50.Node.isCallExpression(init)) {
       calleeText = init.getExpression().getText();
-    } else if (import_ts_morph49.Node.isNewExpression(init)) {
+    } else if (import_ts_morph50.Node.isNewExpression(init)) {
       calleeText = init.getExpression().getText();
     }
     if (calleeText === importedLocalName) {
@@ -10626,7 +10752,7 @@ function registrationSubjectsOf(sourceFile, importModule, importName) {
     }
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph49.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph50.Node.isParameterDeclaration(node)) {
       return;
     }
     const typeNode = node.getTypeNode();
@@ -10670,21 +10796,21 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
   }
   const edges = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph49.Node.isCallExpression(node)) {
+    if (!import_ts_morph50.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph49.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
+    if (!import_ts_morph50.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
       return;
     }
     const subject = callee.getExpression();
-    const subjectNode = import_ts_morph49.Node.isIdentifier(subject) ? subjects.get(subject.getText()) : void 0;
+    const subjectNode = import_ts_morph50.Node.isIdentifier(subject) ? subjects.get(subject.getText()) : void 0;
     if (subjectNode === void 0) {
       return;
     }
     const args = node.getArguments();
     const prefixArg = args[mount.prefixPosition];
-    if (prefixArg === void 0 || !(import_ts_morph49.Node.isStringLiteral(prefixArg) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
+    if (prefixArg === void 0 || !(import_ts_morph50.Node.isStringLiteral(prefixArg) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
       return;
     }
     const targetNodes = mountTargetsAmong(
@@ -10718,15 +10844,15 @@ function mountTargetsAmong(args, targetPosition, knownSubjectIds, resolution) {
   return targets;
 }
 function stringProperty(obj, name) {
-  if (!import_ts_morph49.Node.isObjectLiteralExpression(obj)) {
+  if (!import_ts_morph50.Node.isObjectLiteralExpression(obj)) {
     return null;
   }
   const property = obj.getProperty(name);
-  if (property === void 0 || !import_ts_morph49.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph50.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
-  if (value !== void 0 && (import_ts_morph49.Node.isStringLiteral(value) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(value))) {
+  if (value !== void 0 && (import_ts_morph50.Node.isStringLiteral(value) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(value))) {
     return value.getLiteralValue();
   }
   return null;
@@ -10757,7 +10883,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
   } else {
     const args = call.getArguments();
     const arg = args[binding.method.position];
-    if (arg === void 0 || !(import_ts_morph49.Node.isStringLiteral(arg) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(arg))) {
+    if (arg === void 0 || !(import_ts_morph50.Node.isStringLiteral(arg) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(arg))) {
       return null;
     }
     method = arg.getLiteralValue().toUpperCase();
@@ -10768,7 +10894,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
 }
 
 // src/discovery/registrationLoop.ts
-var import_ts_morph50 = require("ts-morph");
+var import_ts_morph51 = require("ts-morph");
 function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
   const results = [];
   const routables = routableNames(sourceFile, match);
@@ -10776,7 +10902,7 @@ function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph50.Node.isForOfStatement(node)) {
+    if (!import_ts_morph51.Node.isForOfStatement(node)) {
       return;
     }
     const expanded = tryExpandLoop(node, match, kind, resolution, routables);
@@ -10838,13 +10964,13 @@ function tryExpandLoop(loop, match, kind, resolution, routables) {
 }
 function loopVariableName(loop) {
   const initializer = loop.getInitializer();
-  if (import_ts_morph50.Node.isVariableDeclarationList(initializer)) {
+  if (import_ts_morph51.Node.isVariableDeclarationList(initializer)) {
     const decls = initializer.getDeclarations();
     if (decls.length !== 1) {
       return null;
     }
     const nameNode = decls[0]?.getNameNode();
-    if (nameNode !== void 0 && import_ts_morph50.Node.isIdentifier(nameNode)) {
+    if (nameNode !== void 0 && import_ts_morph51.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -10857,14 +10983,14 @@ function bodyReferencesLoopVar(loop, name) {
     if (referenced) {
       return;
     }
-    if (!import_ts_morph50.Node.isCallExpression(node)) {
+    if (!import_ts_morph51.Node.isCallExpression(node)) {
       return;
     }
     node.forEachDescendant((inner) => {
       if (referenced) {
         return;
       }
-      if (import_ts_morph50.Node.isIdentifier(inner) && inner.getText() === name) {
+      if (import_ts_morph51.Node.isIdentifier(inner) && inner.getText() === name) {
         referenced = true;
       }
     });
@@ -10874,12 +11000,12 @@ function bodyReferencesLoopVar(loop, name) {
 function bodyCallsOn(loop, routables) {
   let found = false;
   loop.getStatement().forEachDescendant((node) => {
-    if (found || !import_ts_morph50.Node.isCallExpression(node)) {
+    if (found || !import_ts_morph51.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    const subject = import_ts_morph50.Node.isPropertyAccessExpression(callee) || import_ts_morph50.Node.isElementAccessExpression(callee) ? callee.getExpression() : null;
-    if (subject !== null && import_ts_morph50.Node.isIdentifier(subject) && routables.has(subject.getText())) {
+    const subject = import_ts_morph51.Node.isPropertyAccessExpression(callee) || import_ts_morph51.Node.isElementAccessExpression(callee) ? callee.getExpression() : null;
+    if (subject !== null && import_ts_morph51.Node.isIdentifier(subject) && routables.has(subject.getText())) {
       found = true;
     }
   });
@@ -10890,11 +11016,11 @@ function readRouteSpec(element, shape, resolution) {
   let path13 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
-    if (import_ts_morph50.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
+    if (import_ts_morph51.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
       handler = { func: prop, name: shape.handlerKey };
       continue;
     }
-    if (!import_ts_morph50.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph51.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const name = prop.getName();
@@ -10917,17 +11043,17 @@ function readRouteSpec(element, shape, resolution) {
   return { method, path: path13, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
-  if (import_ts_morph50.Node.isStringLiteral(node) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph51.Node.isStringLiteral(node) || import_ts_morph51.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
 }
 function handlerName(value) {
-  return import_ts_morph50.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph51.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 
 // src/discovery/registrationTemplate.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
   const localName = resolveImportedLocalName2(sourceFile, match);
   if (localName === null) {
@@ -10935,7 +11061,7 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph51.Node.isCallExpression(node)) {
+    if (!import_ts_morph52.Node.isCallExpression(node)) {
       return;
     }
     if (!isCallToHelper(node, localName)) {
@@ -10986,7 +11112,7 @@ function resolveImportedLocalName2(sourceFile, match) {
 }
 function isCallToHelper(call, localName) {
   const callee = call.getExpression();
-  return import_ts_morph51.Node.isIdentifier(callee) && callee.getText() === localName;
+  return import_ts_morph52.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function substitutePath(template, args) {
   const re = /\{(\d+)\}/g;
@@ -11012,7 +11138,7 @@ function substitutePath(template, args) {
   return result;
 }
 function readStringLiteral(node) {
-  if (import_ts_morph51.Node.isStringLiteral(node) || import_ts_morph51.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph52.Node.isStringLiteral(node) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
@@ -11035,7 +11161,7 @@ function resolveHandler(template, args, resolution) {
   return readPropertyAsFunction(arg, prop, resolution);
 }
 function handlerName2(value) {
-  return import_ts_morph51.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph52.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 function readPropertyAsFunction(arg, prop, resolution) {
   const obj = objectLiteralOf(arg, resolution);
@@ -11046,7 +11172,7 @@ function readPropertyAsFunction(arg, prop, resolution) {
     if (propertyName2(property) !== prop) {
       continue;
     }
-    if (import_ts_morph51.Node.isMethodDeclaration(property)) {
+    if (import_ts_morph52.Node.isMethodDeclaration(property)) {
       return { func: property, name: prop };
     }
     const held = propertyValueOf(property);
@@ -11054,19 +11180,19 @@ function readPropertyAsFunction(arg, prop, resolution) {
       return null;
     }
     const func = functionValueOf(held, resolution);
-    return func === null ? null : { func, name: import_ts_morph51.Node.isIdentifier(held) ? held.getText() : prop };
+    return func === null ? null : { func, name: import_ts_morph52.Node.isIdentifier(held) ? held.getText() : prop };
   }
   return null;
 }
 function propertyName2(property) {
-  if (import_ts_morph51.Node.isPropertyAssignment(property) || import_ts_morph51.Node.isShorthandPropertyAssignment(property) || import_ts_morph51.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph52.Node.isPropertyAssignment(property) || import_ts_morph52.Node.isShorthandPropertyAssignment(property) || import_ts_morph52.Node.isMethodDeclaration(property)) {
     return property.getName();
   }
   return null;
 }
 
 // src/discovery/resolverMap.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const localName = resolveImportedLocalName(
     sourceFile,
@@ -11080,15 +11206,15 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const excludeTypes = new Set(match.excludeTypes ?? []);
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph52.Node.isCallExpression(node) && !import_ts_morph52.Node.isNewExpression(node)) {
+    if (!import_ts_morph53.Node.isCallExpression(node) && !import_ts_morph53.Node.isNewExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph52.Node.isIdentifier(callee) || callee.getText() !== localName) {
+    if (!import_ts_morph53.Node.isIdentifier(callee) || callee.getText() !== localName) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph52.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph53.Node.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -11142,7 +11268,7 @@ function resolverMapObject(prop, resolution) {
   return held === null ? null : objectLiteralOf(held, resolution);
 }
 function extractTypeDefsSdl(config, resolution) {
-  if (!import_ts_morph52.Node.isObjectLiteralExpression(config)) {
+  if (!import_ts_morph53.Node.isObjectLiteralExpression(config)) {
     return null;
   }
   const prop = config.getProperty("typeDefs");
@@ -11164,15 +11290,15 @@ function schemaSdlOf(expr, resolution) {
   return resolved === null ? null : writtenSdl(resolved);
 }
 function writtenSdl(expr) {
-  if (import_ts_morph52.Node.isStringLiteral(expr) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph53.Node.isStringLiteral(expr) || import_ts_morph53.Node.isNoSubstitutionTemplateLiteral(expr)) {
     const value = expr.getLiteralValue();
     return value === "" ? null : value;
   }
-  if (import_ts_morph52.Node.isTaggedTemplateExpression(expr)) {
+  if (import_ts_morph53.Node.isTaggedTemplateExpression(expr)) {
     const tag = expr.getTag();
-    if (import_ts_morph52.Node.isIdentifier(tag) && tag.getText() === "gql") {
+    if (import_ts_morph53.Node.isIdentifier(tag) && tag.getText() === "gql") {
       const template = expr.getTemplate();
-      if (import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(template)) {
+      if (import_ts_morph53.Node.isNoSubstitutionTemplateLiteral(template)) {
         return template.getLiteralValue();
       }
     }
@@ -11180,16 +11306,16 @@ function writtenSdl(expr) {
   return null;
 }
 function resolverPropertyName(prop) {
-  if (import_ts_morph52.Node.isPropertyAssignment(prop) || import_ts_morph52.Node.isMethodDeclaration(prop)) {
+  if (import_ts_morph53.Node.isPropertyAssignment(prop) || import_ts_morph53.Node.isMethodDeclaration(prop)) {
     return prop.getName();
   }
-  if (import_ts_morph52.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph53.Node.isShorthandPropertyAssignment(prop)) {
     return prop.getName();
   }
   return null;
 }
 function resolverPropertyFunction(prop, resolution) {
-  if (import_ts_morph52.Node.isMethodDeclaration(prop)) {
+  if (import_ts_morph53.Node.isMethodDeclaration(prop)) {
     return prop;
   }
   const held = propertyValueOf(prop);
@@ -11451,7 +11577,7 @@ function resolvePrefix(edgesByChild, memo, childId, visiting) {
 }
 
 // src/discoveryContext.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 function createTsDiscoveryContext(resolution) {
   return {
     getFilePath,
@@ -11483,7 +11609,7 @@ function exportedFunctions(sourceFile, resolution) {
   return out;
 }
 function exportedFunction(decl, resolution) {
-  const writtenAgain = import_ts_morph53.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
+  const writtenAgain = import_ts_morph54.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
   if (!writtenAgain) {
     const declared = resolveDeclarationToFunction(decl);
     if (declared !== null) {
@@ -11504,7 +11630,7 @@ function valueToAskAbout(decl, writtenAgain) {
   if (writtenAgain) {
     return decl;
   }
-  const value = import_ts_morph53.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
+  const value = import_ts_morph54.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
   return couldStillNameAFunction(value) ? value : null;
 }
 function exportedCallConfigString(sourceFile, exportName, spec, resolution) {
@@ -11514,11 +11640,11 @@ function exportedCallConfigString(sourceFile, exportName, spec, resolution) {
   }
   const found = /* @__PURE__ */ new Set();
   for (const decl of declarations) {
-    if (!import_ts_morph53.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph54.Node.isVariableDeclaration(decl)) {
       continue;
     }
     const init = peelExpression(decl.getInitializer());
-    if (init === void 0 || !import_ts_morph53.Node.isCallExpression(init)) {
+    if (init === void 0 || !import_ts_morph54.Node.isCallExpression(init)) {
       continue;
     }
     if (!calleeIsNamed(init.getExpression(), spec.callees)) {
@@ -11537,7 +11663,7 @@ function calleeIsNamed(callee, names) {
   if (names === void 0 || names.length === 0) {
     return true;
   }
-  return import_ts_morph53.Node.isIdentifier(callee) && names.includes(callee.getText());
+  return import_ts_morph54.Node.isIdentifier(callee) && names.includes(callee.getText());
 }
 function configArguments(args, argIndex) {
   if (argIndex === void 0) {
@@ -11552,18 +11678,18 @@ function configString(arg, property, resolution) {
     return null;
   }
   const prop = config.getProperty(property);
-  if (prop === void 0 || !import_ts_morph53.Node.isPropertyAssignment(prop)) {
+  if (prop === void 0 || !import_ts_morph54.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = peelExpression(prop.getInitializer());
-  if (value !== void 0 && import_ts_morph53.Node.isStringLiteral(value)) {
+  if (value !== void 0 && import_ts_morph54.Node.isStringLiteral(value)) {
     return value.getLiteralValue();
   }
   return null;
 }
 function peelExpression(node) {
   let current2 = node;
-  while (current2 !== void 0 && (import_ts_morph53.Node.isAsExpression(current2) || import_ts_morph53.Node.isSatisfiesExpression(current2) || import_ts_morph53.Node.isParenthesizedExpression(current2) || import_ts_morph53.Node.isNonNullExpression(current2))) {
+  while (current2 !== void 0 && (import_ts_morph54.Node.isAsExpression(current2) || import_ts_morph54.Node.isSatisfiesExpression(current2) || import_ts_morph54.Node.isParenthesizedExpression(current2) || import_ts_morph54.Node.isNonNullExpression(current2))) {
     current2 = current2.getExpression();
   }
   return current2;
@@ -11573,14 +11699,14 @@ function toObjectLiteral(node, resolution) {
   if (peeled === void 0) {
     return null;
   }
-  if (import_ts_morph53.Node.isObjectLiteralExpression(peeled)) {
+  if (import_ts_morph54.Node.isObjectLiteralExpression(peeled)) {
     return peeled;
   }
   if (resolution === void 0) {
     return null;
   }
   const resolved = resolution.resolveObject(peeled);
-  if (resolved !== null && import_ts_morph53.Node.isObjectLiteralExpression(resolved)) {
+  if (resolved !== null && import_ts_morph54.Node.isObjectLiteralExpression(resolved)) {
     return resolved;
   }
   return null;
@@ -11590,18 +11716,18 @@ function resolveDeclarationToFunction(decl) {
   if (fn !== null) {
     return fn;
   }
-  if (import_ts_morph53.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph54.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph53.Node.isArrowFunction(init) || import_ts_morph53.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph54.Node.isArrowFunction(init) || import_ts_morph54.Node.isFunctionExpression(init))) {
       return init;
     }
   }
   return null;
 }
 function hasJsxReturn(func) {
-  if (import_ts_morph53.Node.isArrowFunction(func)) {
+  if (import_ts_morph54.Node.isArrowFunction(func)) {
     const body2 = func.getBody();
-    if (import_ts_morph53.Node.isExpression(body2) && isJsxOrFragment(body2)) {
+    if (import_ts_morph54.Node.isExpression(body2) && isJsxOrFragment(body2)) {
       return true;
     }
   }
@@ -11615,11 +11741,11 @@ function hasJsxReturn(func) {
       traversal.stop();
       return;
     }
-    if (node !== func && (import_ts_morph53.Node.isFunctionDeclaration(node) || import_ts_morph53.Node.isFunctionExpression(node) || import_ts_morph53.Node.isArrowFunction(node) || import_ts_morph53.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph54.Node.isFunctionDeclaration(node) || import_ts_morph54.Node.isFunctionExpression(node) || import_ts_morph54.Node.isArrowFunction(node) || import_ts_morph54.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph53.Node.isReturnStatement(node)) {
+    if (import_ts_morph54.Node.isReturnStatement(node)) {
       const expr = node.getExpression();
       if (expr !== void 0 && isJsxOrFragment(expr)) {
         found = true;
@@ -11630,14 +11756,14 @@ function hasJsxReturn(func) {
 }
 function isJsxOrFragment(node) {
   let current2 = node;
-  while (import_ts_morph53.Node.isParenthesizedExpression(current2)) {
+  while (import_ts_morph54.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
-  return import_ts_morph53.Node.isJsxElement(current2) || import_ts_morph53.Node.isJsxSelfClosingElement(current2) || import_ts_morph53.Node.isJsxFragment(current2);
+  return import_ts_morph54.Node.isJsxElement(current2) || import_ts_morph54.Node.isJsxSelfClosingElement(current2) || import_ts_morph54.Node.isJsxFragment(current2);
 }
 
 // src/facts/store.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 var import_datalog2 = require("@suss/datalog");
 var import_resolution = require("@suss/resolution");
 var JS_RULES = [
@@ -11882,7 +12008,7 @@ var ResolutionStore = class {
    * can be rooted anywhere, so the queried value gets its own facts.
    */
   seedValue(value) {
-    if (!import_ts_morph54.Node.isExpression(value)) {
+    if (!import_ts_morph55.Node.isExpression(value)) {
       return;
     }
     const id = nodeId(value);
@@ -11921,7 +12047,7 @@ var ResolutionStore = class {
     const candidates = /* @__PURE__ */ new Set();
     for (const target of this.answersFor("wantedIsWrittenAs", nodeId(value))) {
       const node = this.table.byId.get(target);
-      if (node === void 0 || node === value || !import_ts_morph54.Node.isExpression(node)) {
+      if (node === void 0 || node === value || !import_ts_morph55.Node.isExpression(node)) {
         continue;
       }
       candidates.add(node);
@@ -12012,7 +12138,7 @@ function namesPackage2(moduleKey, packages) {
   );
 }
 function declarationOf2(value) {
-  const nameNode = import_ts_morph54.Node.isPropertyAccessExpression(value) ? value.getNameNode() : value;
+  const nameNode = import_ts_morph55.Node.isPropertyAccessExpression(value) ? value.getNameNode() : value;
   return nameNode.getSymbol()?.getDeclarations()[0] ?? value;
 }
 
@@ -12144,6 +12270,68 @@ function moduleInitSummary(sourceFile, effects, options) {
   return (0, import_extractor3.assembleSummary)(raw, options);
 }
 
+// src/parameterReads.ts
+var import_ts_morph56 = require("ts-morph");
+function pathAbove(reference) {
+  const path13 = [];
+  let current2 = reference;
+  for (; ; ) {
+    const parent = current2.getParent();
+    if (parent !== void 0 && import_ts_morph56.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
+      path13.push(parent.getName());
+      current2 = parent;
+      continue;
+    }
+    if (parent !== void 0 && import_ts_morph56.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
+      const argument = parent.getArgumentExpression();
+      if (argument !== void 0 && import_ts_morph56.Node.isStringLiteral(argument)) {
+        path13.push(argument.getLiteralValue());
+        current2 = parent;
+        continue;
+      }
+    }
+    return path13;
+  }
+}
+function declaresParameterOf(node, func) {
+  if (import_ts_morph56.Node.isParameterDeclaration(node)) {
+    return node.getParent() === func;
+  }
+  if (import_ts_morph56.Node.isBindingElement(node)) {
+    const parameter = node.getFirstAncestor(import_ts_morph56.Node.isParameterDeclaration);
+    return parameter !== void 0 && parameter.getParent() === func;
+  }
+  return false;
+}
+function parameterReads(func, parameterNames) {
+  const wanted = new Set(parameterNames);
+  if (wanted.size === 0) {
+    return [];
+  }
+  const found = /* @__PURE__ */ new Map();
+  func.forEachDescendant((node) => {
+    if (!import_ts_morph56.Node.isIdentifier(node) || !wanted.has(node.getText())) {
+      return;
+    }
+    const declarations = node.getSymbol()?.getDeclarations() ?? [];
+    if (!declarations.some((decl) => declaresParameterOf(decl, func))) {
+      return;
+    }
+    const inDeclaration = declarations.some(
+      (decl) => decl.getStart() <= node.getStart() && node.getEnd() <= decl.getEnd()
+    );
+    if (inDeclaration) {
+      return;
+    }
+    const read2 = { input: node.getText(), path: pathAbove(node) };
+    const key = `${read2.input}\0${read2.path.join(".")}`;
+    if (!found.has(key)) {
+      found.set(key, read2);
+    }
+  });
+  return [...found.values()];
+}
+
 // src/referencedFiles.ts
 function createReferenceIndex(sourceFiles) {
   const direct = /* @__PURE__ */ new Map();
@@ -12285,108 +12473,10 @@ function deriveBoundaryEffects(summaries, facts) {
 }
 
 // src/resolve/reachableClosure.ts
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
-
-// src/resolve/unfollowedCall.ts
-var import_ts_morph55 = require("ts-morph");
-function isInExternalCode(sourceFile) {
-  if (sourceFile.isDeclarationFile()) {
-    return true;
-  }
-  return sourceFile.getFilePath().includes("/node_modules/");
-}
-function hasBody(fn) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(fn) || import_ts_morph55.Node.isMethodDeclaration(fn) || import_ts_morph55.Node.isFunctionExpression(fn)) {
-    return fn.getBody?.() !== void 0;
-  }
-  return true;
-}
-function isDeclaredShape(declaration) {
-  return (import_ts_morph55.Node.isMethodSignature(declaration) || import_ts_morph55.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
-}
-function isExternalDeclaration(declaration) {
-  if (isInExternalCode(declaration.getSourceFile())) {
-    return true;
-  }
-  if (import_ts_morph55.Node.isImportSpecifier(declaration) || import_ts_morph55.Node.isImportClause(declaration) || import_ts_morph55.Node.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(import_ts_morph55.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
-    return target === void 0 || isInExternalCode(target);
-  }
-  return declaresAnotherModule(declaration);
-}
-function declaresAnotherModule(declaration) {
-  const module2 = declaration.getFirstAncestorByKind(
-    import_ts_morph55.SyntaxKind.ModuleDeclaration
-  );
-  return module2 !== void 0 && import_ts_morph55.Node.isStringLiteral(module2.getNameNode());
-}
-function statesShapeOnly(declaration) {
-  if (isExternalDeclaration(declaration)) {
-    return false;
-  }
-  if (import_ts_morph55.Node.isMethodSignature(declaration) || import_ts_morph55.Node.isPropertySignature(declaration)) {
-    return true;
-  }
-  if (import_ts_morph55.Node.isFunctionDeclaration(declaration) || import_ts_morph55.Node.isMethodDeclaration(declaration)) {
-    return declaration.getBody() === void 0;
-  }
-  return false;
-}
-function declarationsBehind(symbol) {
-  if (symbol === void 0) {
-    return [];
-  }
-  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
-  return behind.length > 0 ? behind : symbol.getDeclarations();
-}
-function classifyStop(declarations) {
-  if (declarations.length === 0) {
-    return "noDeclaration";
-  }
-  for (const declaration of declarations) {
-    if (!isInExternalCode(declaration.getSourceFile())) {
-      recordFileDependency(declaration.getSourceFile().getFilePath());
-    }
-  }
-  if (declarations.every(isExternalDeclaration)) {
-    return "outsideRun";
-  }
-  if (declarations.some(statesShapeOnly)) {
-    return "noBody";
-  }
-  return "unsettledValue";
-}
-var RECORDED = {
-  noBody: true,
-  unsettledValue: true,
-  multipleSources: true,
-  outsideRun: false,
-  noDeclaration: false
-};
-function worthRecording(reason) {
-  return RECORDED[reason];
-}
-var STOP_SENTENCE = {
-  noBody: (callee) => `The call to ${callee} lands on a declaration with no body, so whatever runs there is missing from this summary`,
-  unsettledValue: (callee) => `The call to ${callee} goes through a value this run could not settle, so whatever runs there is missing from this summary`,
-  multipleSources: (callee) => `The call to ${callee} reaches a value with more than one possible source, so whatever runs there is missing from this summary`,
-  outsideRun: (callee) => `The call to ${callee} lands in a package whose source is not in this run, so whatever runs there is missing from this summary`,
-  noDeclaration: (callee) => `The call to ${callee} has no declaration this run could find, so whatever runs there is missing from this summary`
-};
-function unfollowedCallGap(stop) {
-  return {
-    type: "unfollowedCall",
-    conditions: [],
-    consequence: "unknown",
-    description: STOP_SENTENCE[stop.reason](stop.callee),
-    callee: stop.callee
-  };
-}
-
-// src/resolve/reachableClosure.ts
 var reachablePack = {
   name: "reachable",
   languages: ["typescript"],
@@ -12420,9 +12510,9 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph56.Node.isArrowFunction(init) || import_ts_morph56.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph57.Node.isArrowFunction(init) || import_ts_morph57.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
@@ -12430,26 +12520,26 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph56.Node.isFunctionDeclaration(decl) || import_ts_morph56.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph57.Node.isFunctionDeclaration(decl) || import_ts_morph57.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph56.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph57.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_morph56.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph57.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph56.Node.isCallExpression(call)) {
+  if (!import_ts_morph57.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -12462,7 +12552,7 @@ function resolveCallee(call, calleeName, scan) {
     }
   }
   const resolveSources = scan.resolveCallableSources;
-  if (resolveSources !== void 0 && import_ts_morph56.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+  if (resolveSources !== void 0 && import_ts_morph57.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);
@@ -12485,11 +12575,11 @@ function resolveCallee(call, calleeName, scan) {
   };
 }
 function resolveJsxReference(node) {
-  if (!import_ts_morph56.Node.isJsxOpeningElement(node) && !import_ts_morph56.Node.isJsxSelfClosingElement(node)) {
+  if (!import_ts_morph57.Node.isJsxOpeningElement(node) && !import_ts_morph57.Node.isJsxSelfClosingElement(node)) {
     return null;
   }
   const tag = node.getTagNameNode();
-  if (!import_ts_morph56.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
+  if (!import_ts_morph57.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
     return null;
   }
   const name = tag.getText();
@@ -12534,7 +12624,7 @@ function collectReachable(func, scan) {
       record(jsx.outcome);
       return;
     }
-    if (!import_ts_morph56.Node.isCallExpression(node)) {
+    if (!import_ts_morph57.Node.isCallExpression(node)) {
       return;
     }
     const calleeText = normalizeCallee(node.getExpression().getText());
@@ -12604,7 +12694,7 @@ function recognizerOnlyRoots(packsByFile) {
       }
       for (const declaration of variableStatement.getDeclarations()) {
         const init = declaration.getInitializer();
-        if (init !== void 0 && (import_ts_morph56.Node.isArrowFunction(init) || import_ts_morph56.Node.isFunctionExpression(init)) && hasBody(init)) {
+        if (init !== void 0 && (import_ts_morph57.Node.isArrowFunction(init) || import_ts_morph57.Node.isFunctionExpression(init)) && hasBody(init)) {
           roots.push({ func: init, name: declaration.getName() });
         }
       }
@@ -12745,7 +12835,7 @@ function recordStops(stopsByKey, summariesByKey, options) {
 }
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 var import_datalog5 = require("@suss/datalog");
 var RETHROW_RULES = [
   (0, import_datalog5.rule)(
@@ -12885,7 +12975,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph57.Node.isThrowStatement(node)) {
+    if (!import_ts_morph58.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -12895,7 +12985,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph57.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph58.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -12905,13 +12995,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph57.Node.isCatchClause(current2)) {
+    if (import_ts_morph58.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph57.Node.isTryStatement(current2)) {
+    if (import_ts_morph58.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph57.Node.isFunctionDeclaration(current2) || import_ts_morph57.Node.isFunctionExpression(current2) || import_ts_morph57.Node.isArrowFunction(current2) || import_ts_morph57.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph58.Node.isFunctionDeclaration(current2) || import_ts_morph58.Node.isFunctionExpression(current2) || import_ts_morph58.Node.isArrowFunction(current2) || import_ts_morph58.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -12919,14 +13009,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph57.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph58.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph57.Node.isCallExpression(node)) {
+    if (!import_ts_morph58.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -12943,7 +13033,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph57.Node.isCallExpression(call)) {
+  if (!import_ts_morph58.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -12969,12 +13059,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph57.Node.isFunctionDeclaration(decl) || import_ts_morph57.Node.isFunctionExpression(decl) || import_ts_morph57.Node.isArrowFunction(decl) || import_ts_morph57.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph58.Node.isFunctionDeclaration(decl) || import_ts_morph58.Node.isFunctionExpression(decl) || import_ts_morph58.Node.isArrowFunction(decl) || import_ts_morph58.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph58.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph57.Node.isArrowFunction(init) || import_ts_morph57.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph58.Node.isArrowFunction(init) || import_ts_morph58.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -12982,22 +13072,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph58.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph59.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph58.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph59.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph58.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph59.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph58.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph59.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -13018,11 +13108,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph58.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph59.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph58.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph59.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -13054,7 +13144,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph58.Node.isCallExpression(node)) {
+  if (import_ts_morph59.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -13086,14 +13176,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph58.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph59.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_morph58.Node.isArrowFunction(callback) || import_ts_morph58.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph59.Node.isArrowFunction(callback) || import_ts_morph59.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -13101,11 +13191,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph58.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph59.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap2(expr) {
   let node = expr;
-  while (import_ts_morph58.Node.isAwaitExpression(node) || import_ts_morph58.Node.isParenthesizedExpression(node) || import_ts_morph58.Node.isAsExpression(node)) {
+  while (import_ts_morph59.Node.isAwaitExpression(node) || import_ts_morph59.Node.isParenthesizedExpression(node) || import_ts_morph59.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -13115,15 +13205,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph58.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph59.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph58.Node.isExpression(expr) ? unwrap2(expr) : expr;
-  if (import_ts_morph58.Node.isCallExpression(node)) {
+  let node = import_ts_morph59.Node.isExpression(expr) ? unwrap2(expr) : expr;
+  if (import_ts_morph59.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph58.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph59.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -13142,16 +13232,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph58.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph59.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph59.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph58.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph59.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -13162,7 +13252,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph58.Node.isIdentifier(node)) {
+    if (!import_ts_morph59.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -13174,13 +13264,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph58.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph59.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph59.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -13194,15 +13284,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph58.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph59.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph58.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph59.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph58.Node.isFunctionLikeDeclaration(current2) || import_ts_morph58.Node.isVariableStatement(current2)) {
+    if (import_ts_morph59.Node.isFunctionLikeDeclaration(current2) || import_ts_morph59.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -13265,7 +13355,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph58.Node.isIfStatement(parent)) {
+    if (import_ts_morph59.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -13327,7 +13417,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph59 = require("ts-morph");
+var import_ts_morph60 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -13340,7 +13430,7 @@ function createTsSubUnitContext() {
 }
 function skipNestedFunctions(parent) {
   return (node, traversal) => {
-    if (node !== parent && (import_ts_morph59.Node.isFunctionDeclaration(node) || import_ts_morph59.Node.isFunctionExpression(node) || import_ts_morph59.Node.isArrowFunction(node) || import_ts_morph59.Node.isMethodDeclaration(node))) {
+    if (node !== parent && (import_ts_morph60.Node.isFunctionDeclaration(node) || import_ts_morph60.Node.isFunctionExpression(node) || import_ts_morph60.Node.isArrowFunction(node) || import_ts_morph60.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return true;
     }
@@ -13354,18 +13444,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph59.Node.isJsxOpeningElement(node) && !import_ts_morph59.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph60.Node.isJsxOpeningElement(node) && !import_ts_morph60.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph59.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph60.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph59.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph60.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -13388,11 +13478,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph59.Node.isCallExpression(node)) {
+    if (!import_ts_morph60.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph60.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -13403,10 +13493,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph59.Node.isArrowFunction(expr) || import_ts_morph59.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph60.Node.isArrowFunction(expr) || import_ts_morph60.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph59.Node.isIdentifier(expr)) {
+  if (import_ts_morph60.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -13425,15 +13515,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph59.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph60.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph59.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph60.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph59.Node.isArrowFunction(init) || import_ts_morph59.Node.isFunctionExpression(init)) {
+    if (import_ts_morph60.Node.isArrowFunction(init) || import_ts_morph60.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -13454,7 +13544,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph59.Node.isArrowFunction(arg) || import_ts_morph59.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph60.Node.isArrowFunction(arg) || import_ts_morph60.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -13466,7 +13556,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph59.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph60.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -13884,13 +13974,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph60.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph61.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph60.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph61.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph60.Node.isOmittedExpression(element)) {
+      if (import_ts_morph61.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -13920,7 +14010,7 @@ function objectParamInputs(param, position, mapping) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph60.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph61.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -13969,7 +14059,17 @@ function extractParameters(func, inputMapping) {
       const param = params[i];
       const nameNode = param.getNameNode();
       const boundNames = bindingPatternNames(nameNode);
-      if (boundNames !== null) {
+      if (import_ts_morph61.Node.isObjectBindingPattern(nameNode)) {
+        for (const element of nameNode.getElements()) {
+          const rest = element.getDotDotDotToken() !== void 0;
+          result.push({
+            name: element.getName(),
+            position: i,
+            role: rest ? "rest" : inputMapping.defaultRole ?? element.getName(),
+            typeText: null
+          });
+        }
+      } else if (boundNames !== null) {
         for (const name of boundNames) {
           result.push({
             name,
@@ -14023,11 +14123,11 @@ function extractParameters(func, inputMapping) {
 function extractDependencyCalls(func) {
   const results = [];
   func.forEachDescendant((node, traversal) => {
-    if (node !== func && (import_ts_morph60.Node.isFunctionDeclaration(node) || import_ts_morph60.Node.isFunctionExpression(node) || import_ts_morph60.Node.isArrowFunction(node) || import_ts_morph60.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph61.Node.isFunctionDeclaration(node) || import_ts_morph61.Node.isFunctionExpression(node) || import_ts_morph61.Node.isArrowFunction(node) || import_ts_morph61.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph60.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph61.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -14036,19 +14136,19 @@ function extractDependencyCalls(func) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph60.Node.isAwaitExpression(init)) {
+    if (import_ts_morph61.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph60.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph61.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph60.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph61.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph60.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph61.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -14228,6 +14328,10 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
     barriers
   );
   const depCalls = extractDependencyCalls(func);
+  const paramReads = parameterReads(
+    func,
+    params.map((one) => one.name)
+  );
   if (unit.callSite !== void 0) {
     const calleeText = unit.callSite.callExpression.getExpression().getText();
     if (pack.responseSemantics !== void 0) {
@@ -14275,6 +14379,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
     bodyContent: bodyContentOf(func),
     dependencyCalls: depCalls,
     declaredContract: null,
+    ...paramReads.length > 0 ? { extraInputReads: paramReads } : {},
     ...accessors,
     ...unit.callSite !== void 0 && pack.failureDelivery !== void 0 ? { failureDelivery: pack.failureDelivery } : {}
   };
@@ -14333,9 +14438,9 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
   if (m.type === "fromArgumentProperty") {
     const args = callSite.callExpression.getArguments();
     const arg = args[m.position];
-    if (arg !== void 0 && import_ts_morph60.Node.isObjectLiteralExpression(arg)) {
+    if (arg !== void 0 && import_ts_morph61.Node.isObjectLiteralExpression(arg)) {
       const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && import_ts_morph60.Node.isPropertyAssignment(prop)) {
+      if (prop !== void 0 && import_ts_morph61.Node.isPropertyAssignment(prop)) {
         const init = prop.getInitializer();
         if (init !== void 0) {
           const value = stringValueOf(init, resolution);
@@ -14872,9 +14977,9 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(import_ts_morph60.SyntaxKind.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(import_ts_morph61.SyntaxKind.CallExpression)) {
     const first = call.getArguments()[0];
-    if (first === void 0 || !import_ts_morph60.Node.isIdentifier(first)) {
+    if (first === void 0 || !import_ts_morph61.Node.isIdentifier(first)) {
       continue;
     }
     const at = names.indexOf(first.getText());
@@ -14923,16 +15028,16 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph60.Node.isFunctionDeclaration(func) || import_ts_morph60.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph61.Node.isFunctionDeclaration(func) || import_ts_morph61.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph60.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph61.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph60.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph61.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph60.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph61.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -14941,10 +15046,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph60.Node.isCallExpression(current2)) {
+    if (import_ts_morph61.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph60.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph61.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -14955,7 +15060,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph60.Node.isFunctionDeclaration(current2) || import_ts_morph60.Node.isFunctionExpression(current2) || import_ts_morph60.Node.isArrowFunction(current2) || import_ts_morph60.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph61.Node.isFunctionDeclaration(current2) || import_ts_morph61.Node.isFunctionExpression(current2) || import_ts_morph61.Node.isArrowFunction(current2) || import_ts_morph61.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -14963,13 +15068,13 @@ function enclosingFunction(node) {
   return null;
 }
 function callerName(func) {
-  if (import_ts_morph60.Node.isFunctionDeclaration(func) || import_ts_morph60.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph61.Node.isFunctionDeclaration(func) || import_ts_morph61.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph60.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph61.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph60.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph61.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -15081,7 +15186,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? import_node_path10.default.dirname(suppliedConfig.tsConfigFilePath) : void 0)
     )
   };
-  const project = config.project ?? new import_ts_morph60.Project(
+  const project = config.project ?? new import_ts_morph61.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -15760,7 +15865,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path11 = __toESM(require("path"), 1);
-var import_ts_morph61 = require("ts-morph");
+var import_ts_morph62 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -15808,12 +15913,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph61.Project({
+  const project = new import_ts_morph62.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph61.ScriptTarget.ES2022,
-      module: import_ts_morph61.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph61.ModuleResolutionKind.Bundler,
+      target: import_ts_morph62.ScriptTarget.ES2022,
+      module: import_ts_morph62.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph62.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -15854,7 +15959,7 @@ function findNearestTsconfig(startDir) {
 
 // src/facts/why.ts
 var import_node_path12 = __toESM(require("path"), 1);
-var import_ts_morph62 = require("ts-morph");
+var import_ts_morph63 = require("ts-morph");
 var import_resolution2 = require("@suss/resolution");
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -15868,7 +15973,7 @@ var WhySession = class {
   constructor(options) {
     this.root = import_node_path12.default.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
-    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph62.Project({ tsConfigFilePath: tsconfig });
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph63.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
   }
   /**
@@ -15883,7 +15988,7 @@ var WhySession = class {
     }
     let found = null;
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph62.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+      if (import_ts_morph63.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
         found = node;
       }
     });
@@ -15901,7 +16006,7 @@ var WhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      import_ts_morph62.SyntaxKind.CallExpression
+      import_ts_morph63.SyntaxKind.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -15975,21 +16080,21 @@ var WhySession = class {
   }
 };
 function displayNameOf(node) {
-  if (import_ts_morph62.Node.isIdentifier(node) || import_ts_morph62.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph63.Node.isIdentifier(node) || import_ts_morph63.Node.isPropertyAccessExpression(node)) {
     return node.getText();
   }
-  if (import_ts_morph62.Node.isCallExpression(node) || import_ts_morph62.Node.isNewExpression(node)) {
+  if (import_ts_morph63.Node.isCallExpression(node) || import_ts_morph63.Node.isNewExpression(node)) {
     return `${node.getExpression()?.getText() ?? "call"}(...)`;
   }
-  if (import_ts_morph62.Node.isFunctionDeclaration(node) || import_ts_morph62.Node.isClassDeclaration(node) || import_ts_morph62.Node.isMethodDeclaration(node) || import_ts_morph62.Node.isVariableDeclaration(node)) {
+  if (import_ts_morph63.Node.isFunctionDeclaration(node) || import_ts_morph63.Node.isClassDeclaration(node) || import_ts_morph63.Node.isMethodDeclaration(node) || import_ts_morph63.Node.isVariableDeclaration(node)) {
     const name = node.getName();
     if (name !== void 0) {
       return name;
     }
   }
-  if (import_ts_morph62.Node.isArrowFunction(node) || import_ts_morph62.Node.isFunctionExpression(node)) {
+  if (import_ts_morph63.Node.isArrowFunction(node) || import_ts_morph63.Node.isFunctionExpression(node)) {
     const parent = node.getParent();
-    if (parent !== void 0 && import_ts_morph62.Node.isVariableDeclaration(parent)) {
+    if (parent !== void 0 && import_ts_morph63.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
   }