@suss/adapter-typescript 0.22.4 → 0.24.0

package/dist/index.cjs

@@ -78,13 +78,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path10 = __toESM(require("path"), 1);
-var import_ts_morph66 = require("ts-morph");
+var import_ts_morph67 = require("ts-morph");
 var import_behavioral_ir8 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor11 = require("@suss/extractor");
 
 // src/assembly.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 var import_extractor5 = require("@suss/extractor");
 
 // src/conditions.ts
@@ -10181,7 +10181,7 @@ function enclosingStatementLine(node) {
 }
 
 // src/terminals/index.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 
 // src/terminals/continuation.ts
 var import_ts_morph45 = require("ts-morph");
@@ -10253,14 +10253,15 @@ function tryMatchParameterCall(node, func, pattern, match) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph48 = require("ts-morph");
 var import_values5 = require("@suss/values");
 
 // src/shapes/shapes.ts
-var import_ts_morph46 = require("ts-morph");
+var import_ts_morph47 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
+var import_ts_morph46 = require("ts-morph");
 
 // src/shapes/definitions.ts
 var current = null;
@@ -10422,7 +10423,7 @@ function typeToShape(type, ctx) {
   if (type.isEnum() || type.isEnumLiteral()) {
     return enumToShape(type, ctx);
   }
-  const text = type.getText(ctx.enclosing);
+  const text = printedTypeName(type, ctx);
   if (text && text.length > 0 && text !== "__type") {
     return { type: "ref", name: text };
   }
@@ -10470,8 +10471,7 @@ function intersectionToShape(type, ctx) {
   if (nonRecords.length === 1 && records.length === 0) {
     return nonRecords[0];
   }
-  const text = type.getText(ctx.enclosing);
-  return { type: "ref", name: text };
+  return { type: "ref", name: printedTypeName(type, ctx) };
 }
 function objectToShape(type, ctx) {
   const key = typeKey(type, ctx.enclosing);
@@ -10531,7 +10531,7 @@ function opaqueNamedRef(type, ctx) {
   if (!OPAQUE_NAMED_TYPES.has(name)) {
     return null;
   }
-  const text = type.getText(ctx.enclosing);
+  const text = printedTypeName(type, ctx);
   return { type: "ref", name: text && text.length > 0 ? text : name };
 }
 function outsideProjectRef(type, ctx) {
@@ -10612,6 +10612,12 @@ function refFromType(type, ctx) {
   }
   return { type: "ref", name: withoutImportQualifiers(type.getText()) };
 }
+var PRINTED_NAME_FLAGS = import_ts_morph46.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | import_ts_morph46.TypeFormatFlags.UseTypeOfFunction | import_ts_morph46.TypeFormatFlags.NoTruncation | import_ts_morph46.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+function printedTypeName(type, ctx) {
+  return withoutImportQualifiers(
+    type.getText(ctx.enclosing, PRINTED_NAME_FLAGS)
+  );
+}
 var IMPORT_QUALIFIER = /import\("[^"]*"\)\./g;
 var withoutImportQualifiers = (text) => text.replace(IMPORT_QUALIFIER, "");
 function declaringFileOf(symbol) {
@@ -10716,60 +10722,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph46.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph47.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph46.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph46.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph46.Node.isStringLiteral(unwrapped2) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isStringLiteral(unwrapped2) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph46.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph46.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph46.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph46.SyntaxKind.MinusToken || op === import_ts_morph46.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph47.SyntaxKind.MinusToken || op === import_ts_morph47.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph46.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph47.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph46.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph47.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph46.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph47.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph46.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph47.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph46.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph46.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph46.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph47.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph46.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph47.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph46.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph47.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -10800,7 +10806,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph46.Node.isSpreadElement(el)) {
+    if (import_ts_morph47.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -10819,7 +10825,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph46.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph47.Node.isPropertyAssignment(prop)) {
       const name = propertyName2(prop);
       if (name === null) {
         continue;
@@ -10835,7 +10841,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph46.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -10844,7 +10850,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph46.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph47.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -10863,7 +10869,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName2(prop) {
   const nameNode = prop.getNameNode();
-  if (import_ts_morph46.Node.isIdentifier(nameNode) || import_ts_morph46.Node.isStringLiteral(nameNode) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph46.Node.isNumericLiteral(nameNode)) {
+  if (import_ts_morph47.Node.isIdentifier(nameNode) || import_ts_morph47.Node.isStringLiteral(nameNode) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph47.Node.isNumericLiteral(nameNode)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -10894,15 +10900,15 @@ function unwrapAs(node) {
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph47.Node.isCallExpression(outer)) {
+  if (!import_ts_morph48.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph47.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph47.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph48.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -10912,7 +10918,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph47.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph48.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -10956,10 +10962,10 @@ function statusFromProperty(obj, name, ctx) {
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -10982,7 +10988,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph47.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph48.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -10995,7 +11001,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph47.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph48.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -11004,7 +11010,7 @@ function extractStatusCodeFromRule(ctx) {
   if (sc.from === "argumentProperty") {
     const args = ctx.throwCallArgs ?? ctx.calls?.[0]?.getArguments();
     const arg = args?.[sc.position];
-    if (arg === void 0 || !import_ts_morph47.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph48.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -11014,8 +11020,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11073,8 +11079,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11129,16 +11135,16 @@ function extractBody(ctx) {
 }
 
 // src/terminals/jsx.ts
-var import_ts_morph48 = require("ts-morph");
+var import_ts_morph49 = require("ts-morph");
 function tryMatchJsxReturn(node, pattern) {
   let expr;
   let source;
-  if (import_ts_morph48.Node.isReturnStatement(node)) {
+  if (import_ts_morph49.Node.isReturnStatement(node)) {
     expr = node.getExpression();
     source = node;
-  } else if (import_ts_morph48.Node.isArrowFunction(node)) {
+  } else if (import_ts_morph49.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph48.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph49.Node.isBlock(body)) {
       expr = body;
       source = body;
     }
@@ -11169,14 +11175,14 @@ function tryMatchJsxReturn(node, pattern) {
   return { node, source, terminal };
 }
 function componentTargetOf(tagNode) {
-  if (!import_ts_morph48.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+  if (!import_ts_morph49.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
     return null;
   }
   const target = functionTargetOf(tagNode);
   return target === null ? null : { file: target.file, name: target.name };
 }
 function jsxToRenderNode(node) {
-  if (import_ts_morph48.Node.isJsxElement(node)) {
+  if (import_ts_morph49.Node.isJsxElement(node)) {
     const opening = node.getOpeningElement();
     const tag = opening.getTagNameNode().getText();
     const attrs = collectJsxAttributes(opening);
@@ -11190,7 +11196,7 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph48.Node.isJsxSelfClosingElement(node)) {
+  if (import_ts_morph49.Node.isJsxSelfClosingElement(node)) {
     const tag = node.getTagNameNode().getText();
     const attrs = collectJsxAttributes(node);
     const target = componentTargetOf(node.getTagNameNode());
@@ -11202,11 +11208,11 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph48.Node.isJsxFragment(node)) {
+  if (import_ts_morph49.Node.isJsxFragment(node)) {
     const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
     return { type: "element", tag: "Fragment", children };
   }
-  if (import_ts_morph48.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph49.Node.isParenthesizedExpression(node)) {
     return jsxToRenderNode(node.getExpression());
   }
   return null;
@@ -11214,12 +11220,12 @@ function jsxToRenderNode(node) {
 function collectJsxAttributes(opening) {
   const entries = {};
   for (const attr of opening.getAttributes()) {
-    if (import_ts_morph48.Node.isJsxSpreadAttribute(attr)) {
+    if (import_ts_morph49.Node.isJsxSpreadAttribute(attr)) {
       const exprText = attr.getExpression().getText();
       entries[`...${exprText}`] = exprText;
       continue;
     }
-    if (!import_ts_morph48.Node.isJsxAttribute(attr)) {
+    if (!import_ts_morph49.Node.isJsxAttribute(attr)) {
       continue;
     }
     const name = attr.getNameNode().getText();
@@ -11228,7 +11234,7 @@ function collectJsxAttributes(opening) {
       entries[name] = "";
       continue;
     }
-    if (import_ts_morph48.Node.isJsxExpression(initializer)) {
+    if (import_ts_morph49.Node.isJsxExpression(initializer)) {
       const inner = initializer.getExpression();
       entries[name] = inner !== void 0 ? inner.getText() : "";
       continue;
@@ -11238,30 +11244,30 @@ function collectJsxAttributes(opening) {
   return Object.keys(entries).length > 0 ? entries : null;
 }
 function jsxChildToRenderNode(child) {
-  if (import_ts_morph48.Node.isJsxText(child)) {
+  if (import_ts_morph49.Node.isJsxText(child)) {
     const text = child.getLiteralText().trim();
     if (text.length === 0) {
       return null;
     }
     return { type: "text", value: text };
   }
-  if (import_ts_morph48.Node.isJsxExpression(child)) {
+  if (import_ts_morph49.Node.isJsxExpression(child)) {
     const inner = child.getExpression();
     if (inner === void 0) {
       return null;
     }
     return jsxExpressionToRenderNode(inner);
   }
-  if (import_ts_morph48.Node.isJsxElement(child) || import_ts_morph48.Node.isJsxSelfClosingElement(child) || import_ts_morph48.Node.isJsxFragment(child)) {
+  if (import_ts_morph49.Node.isJsxElement(child) || import_ts_morph49.Node.isJsxSelfClosingElement(child) || import_ts_morph49.Node.isJsxFragment(child)) {
     return jsxToRenderNode(child);
   }
   return null;
 }
 function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph48.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph49.Node.isParenthesizedExpression(expr)) {
     return jsxExpressionToRenderNode(expr.getExpression());
   }
-  if (import_ts_morph48.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph49.Node.isBinaryExpression(expr)) {
     const op = expr.getOperatorToken().getText();
     if (op === "&&") {
       const right = renderAlternative(peelParens(expr.getRight()));
@@ -11275,7 +11281,7 @@ function jsxExpressionToRenderNode(expr) {
       }
     }
   }
-  if (import_ts_morph48.Node.isConditionalExpression(expr)) {
+  if (import_ts_morph49.Node.isConditionalExpression(expr)) {
     const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
     const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
     if (truthy.kind === "jsx") {
@@ -11298,16 +11304,16 @@ function jsxExpressionToRenderNode(expr) {
   return { type: "expression", sourceText: expr.getText() };
 }
 function renderAlternative(node) {
-  if (import_ts_morph48.Node.isNullLiteral(node)) {
+  if (import_ts_morph49.Node.isNullLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isFalseLiteral(node)) {
+  if (import_ts_morph49.Node.isFalseLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isIdentifier(node) && node.getText() === "undefined") {
+  if (import_ts_morph49.Node.isIdentifier(node) && node.getText() === "undefined") {
     return { kind: "noRender" };
   }
-  if (import_ts_morph48.Node.isJsxElement(node) || import_ts_morph48.Node.isJsxSelfClosingElement(node) || import_ts_morph48.Node.isJsxFragment(node)) {
+  if (import_ts_morph49.Node.isJsxElement(node) || import_ts_morph49.Node.isJsxSelfClosingElement(node) || import_ts_morph49.Node.isJsxFragment(node)) {
     const tree = jsxToRenderNode(node);
     if (tree !== null) {
       return { kind: "jsx", node: tree };
@@ -11317,13 +11323,13 @@ function renderAlternative(node) {
 }
 
 // src/terminals/returns.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 
 // src/terminals/helperResolution.ts
-var import_ts_morph49 = require("ts-morph");
+var import_ts_morph50 = require("ts-morph");
 function resolveHelperReturn(call, resolveCallee2) {
   const callee = call.getExpression();
-  if (!import_ts_morph49.Node.isIdentifier(callee)) {
+  if (!import_ts_morph50.Node.isIdentifier(callee)) {
     return { kind: "notLocal" };
   }
   const helper = memoizedLocalHelper(callee, resolveCallee2);
@@ -11353,16 +11359,16 @@ function guardsAbove(returnValue) {
   let child = returnValue;
   let current2 = returnValue.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph49.Node.isIfStatement(current2)) {
+    if (import_ts_morph50.Node.isIfStatement(current2)) {
       guards.push({
         condition: current2.getExpression(),
         whenTrue: current2.getThenStatement() === child
       });
     }
-    if (import_ts_morph49.Node.isBlock(current2)) {
+    if (import_ts_morph50.Node.isBlock(current2)) {
       guards.push(...earlyReturnGuardsBefore(current2, child));
     }
-    if (import_ts_morph49.Node.isFunctionDeclaration(current2) || import_ts_morph49.Node.isArrowFunction(current2) || import_ts_morph49.Node.isFunctionExpression(current2)) {
+    if (import_ts_morph50.Node.isFunctionDeclaration(current2) || import_ts_morph50.Node.isArrowFunction(current2) || import_ts_morph50.Node.isFunctionExpression(current2)) {
       break;
     }
     child = current2;
@@ -11371,7 +11377,7 @@ function guardsAbove(returnValue) {
   return guards;
 }
 function earlyReturnGuardsBefore(block, child) {
-  if (!import_ts_morph49.Node.isBlock(block)) {
+  if (!import_ts_morph50.Node.isBlock(block)) {
     return [];
   }
   const guards = [];
@@ -11379,7 +11385,7 @@ function earlyReturnGuardsBefore(block, child) {
     if (statement === child) {
       break;
     }
-    if (!import_ts_morph49.Node.isIfStatement(statement) || statement.getElseStatement()) {
+    if (!import_ts_morph50.Node.isIfStatement(statement) || statement.getElseStatement()) {
       continue;
     }
     if (alwaysReturns(statement.getThenStatement())) {
@@ -11389,10 +11395,10 @@ function earlyReturnGuardsBefore(block, child) {
   return guards;
 }
 function alwaysReturns(statement) {
-  if (import_ts_morph49.Node.isReturnStatement(statement) || import_ts_morph49.Node.isThrowStatement(statement)) {
+  if (import_ts_morph50.Node.isReturnStatement(statement) || import_ts_morph50.Node.isThrowStatement(statement)) {
     return true;
   }
-  if (!import_ts_morph49.Node.isBlock(statement)) {
+  if (!import_ts_morph50.Node.isBlock(statement)) {
     return false;
   }
   const statements = statement.getStatements();
@@ -11410,7 +11416,7 @@ var COMPARISONS = {
   "!=": (a, b) => a !== b
 };
 function evaluateComparison(condition, substitutions) {
-  if (!import_ts_morph49.Node.isBinaryExpression(condition)) {
+  if (!import_ts_morph50.Node.isBinaryExpression(condition)) {
     return null;
   }
   const left = numberFor(condition.getLeft(), substitutions);
@@ -11422,8 +11428,8 @@ function evaluateComparison(condition, substitutions) {
   return compare === void 0 ? null : compare(left, right);
 }
 function numberFor(node, substitutions) {
-  const resolved = import_ts_morph49.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
-  return import_ts_morph49.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
+  const resolved = import_ts_morph50.Node.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
+  return import_ts_morph50.Node.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
 }
 var helperBySymbol = /* @__PURE__ */ new WeakMap();
 function memoizedLocalHelper(callee, resolveCallee2) {
@@ -11510,12 +11516,12 @@ function declarationsFor(callee, resolveCallee2) {
   return (aliased ?? symbol).getDeclarations();
 }
 function asFunctionLike(declaration) {
-  if (import_ts_morph49.Node.isFunctionDeclaration(declaration) || import_ts_morph49.Node.isArrowFunction(declaration) || import_ts_morph49.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph50.Node.isFunctionDeclaration(declaration) || import_ts_morph50.Node.isArrowFunction(declaration) || import_ts_morph50.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (import_ts_morph49.Node.isVariableDeclaration(declaration)) {
+  if (import_ts_morph50.Node.isVariableDeclaration(declaration)) {
     const initializer = declaration.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph49.Node.isArrowFunction(initializer) || import_ts_morph49.Node.isFunctionExpression(initializer))) {
+    if (initializer !== void 0 && (import_ts_morph50.Node.isArrowFunction(initializer) || import_ts_morph50.Node.isFunctionExpression(initializer))) {
       return initializer;
     }
   }
@@ -11526,13 +11532,13 @@ function returnedObjects(fn) {
   if (body === void 0) {
     return [];
   }
-  if (!import_ts_morph49.Node.isBlock(body)) {
+  if (!import_ts_morph50.Node.isBlock(body)) {
     const expression = peelParens(body);
-    return import_ts_morph49.Node.isObjectLiteralExpression(expression) ? [expression] : [];
+    return import_ts_morph50.Node.isObjectLiteralExpression(expression) ? [expression] : [];
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    import_ts_morph49.SyntaxKind.ReturnStatement
+    import_ts_morph50.SyntaxKind.ReturnStatement
   )) {
     if (enclosingFunctionOf(statement) !== body) {
       continue;
@@ -11542,7 +11548,7 @@ function returnedObjects(fn) {
       continue;
     }
     const unwrapped2 = peelParens(expression);
-    if (import_ts_morph49.Node.isObjectLiteralExpression(unwrapped2)) {
+    if (import_ts_morph50.Node.isObjectLiteralExpression(unwrapped2)) {
       found.push(unwrapped2);
     }
   }
@@ -11551,7 +11557,7 @@ function returnedObjects(fn) {
 function enclosingFunctionOf(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph49.Node.isFunctionDeclaration(current2) || import_ts_morph49.Node.isArrowFunction(current2) || import_ts_morph49.Node.isFunctionExpression(current2) || import_ts_morph49.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph50.Node.isFunctionDeclaration(current2) || import_ts_morph50.Node.isArrowFunction(current2) || import_ts_morph50.Node.isFunctionExpression(current2) || import_ts_morph50.Node.isMethodDeclaration(current2)) {
       return current2.getBody();
     }
     current2 = current2.getParent();
@@ -11570,7 +11576,7 @@ function bindArguments(callArgs, params) {
 }
 
 // src/terminals/statusBranches.ts
-var import_ts_morph50 = require("ts-morph");
+var import_ts_morph51 = require("ts-morph");
 var import_values6 = require("@suss/values");
 function statusChoicesOf(argument, resolution) {
   const chosen = asConditional(argument);
@@ -11594,10 +11600,10 @@ function asConditional(node) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph50.Node.isIdentifier(node)) {
+  if (!import_ts_morph51.Node.isIdentifier(node)) {
     return null;
   }
-  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph50.Node.isVariableDeclaration);
+  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph51.Node.isVariableDeclaration);
   if (declaration === void 0) {
     return null;
   }
@@ -11608,7 +11614,7 @@ function asConditional(node) {
   const only = written.values[0];
   return only === void 0 ? null : toConditional(only);
 }
-var toConditional = (node) => import_ts_morph50.Node.isConditionalExpression(node) ? node : null;
+var toConditional = (node) => import_ts_morph51.Node.isConditionalExpression(node) ? node : null;
 function numberOf(node, resolution) {
   const value = (0, import_values6.constantOf)(evaluatedValue(node, resolution));
   return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -11625,7 +11631,7 @@ function unwrapMethodChain(call, match, func) {
   for (let i = methodChain.length - 1; i >= 0; i--) {
     const expectedMethod = methodChain[i];
     const callee = current2.getExpression();
-    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph52.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     if (callee.getName() !== expectedMethod) {
@@ -11641,7 +11647,7 @@ function unwrapMethodChain(call, match, func) {
         return null;
       }
     } else {
-      if (!import_ts_morph51.Node.isCallExpression(subject)) {
+      if (!import_ts_morph52.Node.isCallExpression(subject)) {
         return null;
       }
       current2 = subject;
@@ -11651,9 +11657,9 @@ function unwrapMethodChain(call, match, func) {
 }
 function withoutPassThroughCalls(subject, passThrough) {
   let current2 = subject;
-  while (import_ts_morph51.Node.isCallExpression(current2)) {
+  while (import_ts_morph52.Node.isCallExpression(current2)) {
     const callee = current2.getExpression();
-    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
+    if (!import_ts_morph52.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
       break;
     }
     current2 = callee.getExpression();
@@ -11665,12 +11671,12 @@ function returnedValueOf(returnStatement) {
   return written === void 0 ? null : unwrapValue(written);
 }
 function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
-  if (import_ts_morph51.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph52.Node.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
       return [];
     }
-    if (import_ts_morph51.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
+    if (import_ts_morph52.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
       return [];
     }
     const terminal = terminalFromReturnedObject(
@@ -11683,14 +11689,14 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
-  if (!import_ts_morph51.Node.isReturnStatement(node)) {
+  if (!import_ts_morph52.Node.isReturnStatement(node)) {
     return [];
   }
   const returned = returnedValueOf(node);
   if (returned === null) {
     return [];
   }
-  if (import_ts_morph51.Node.isObjectLiteralExpression(returned)) {
+  if (import_ts_morph52.Node.isObjectLiteralExpression(returned)) {
     const terminal = terminalFromReturnedObject(
       returned,
       node,
@@ -11701,7 +11707,7 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [terminal];
   }
-  if (!import_ts_morph51.Node.isCallExpression(returned)) {
+  if (!import_ts_morph52.Node.isCallExpression(returned)) {
     return [];
   }
   const resolved = resolveHelperReturn(returned, resolveCallee2);
@@ -11738,7 +11744,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   if (required !== void 0 && required.length > 0) {
     const presentNames = /* @__PURE__ */ new Set();
     for (const prop of obj.getProperties()) {
-      if (import_ts_morph51.Node.isPropertyAssignment(prop) || import_ts_morph51.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph52.Node.isPropertyAssignment(prop) || import_ts_morph52.Node.isShorthandPropertyAssignment(prop)) {
         presentNames.add(prop.getName());
       }
     }
@@ -11764,7 +11770,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
     // When a helper built the value, the anchor is the caller's own
     // return, so it doubles as the provenance. A value reached any other
     // way leaves this unset and its caller fills it in.
-    ...import_ts_morph51.Node.isReturnStatement(anchor) ? { source: anchor } : {},
+    ...import_ts_morph52.Node.isReturnStatement(anchor) ? { source: anchor } : {},
     terminal: {
       kind: pattern.kind,
       statusCode,
@@ -11783,7 +11789,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   };
 }
 function tryMatchParameterMethodCall(node, func, pattern, match, resolution) {
-  if (!import_ts_morph51.Node.isCallExpression(node)) {
+  if (!import_ts_morph52.Node.isCallExpression(node)) {
     return [];
   }
   const result = unwrapMethodChain(node, match, func);
@@ -11843,7 +11849,7 @@ function statusArgument(calls, extraction) {
 }
 function returnCoveredByParameterMethodCall(expr, func, patterns) {
   const current2 = unwrapValue(expr);
-  if (!import_ts_morph51.Node.isCallExpression(current2)) {
+  if (!import_ts_morph52.Node.isCallExpression(current2)) {
     return false;
   }
   for (const pattern of patterns) {
@@ -11859,7 +11865,7 @@ function returnCoveredByParameterMethodCall(expr, func, patterns) {
 }
 function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   const match = pattern.match.type === "returnStatement" ? pattern.match : null;
-  if (import_ts_morph51.Node.isReturnStatement(node)) {
+  if (import_ts_morph52.Node.isReturnStatement(node)) {
     const expr = node.getExpression();
     if (match?.excludeCallReturns === true) {
       if (expr === void 0) {
@@ -11878,9 +11884,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
     }
     return buildReturnTerminal(node, pattern, body);
   }
-  if (import_ts_morph51.Node.isArrowFunction(node)) {
+  if (import_ts_morph52.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body === void 0 || import_ts_morph51.Node.isBlock(body)) {
+    if (body === void 0 || import_ts_morph52.Node.isBlock(body)) {
       return null;
     }
     const shape = extractShape(body);
@@ -11938,20 +11944,20 @@ function unresolvedTerminal(kind, node) {
   };
 }
 function calleeSubject(callee) {
-  if (import_ts_morph51.Node.isIdentifier(callee)) {
+  if (import_ts_morph52.Node.isIdentifier(callee)) {
     return callee;
   }
-  if (import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph52.Node.isPropertyAccessExpression(callee)) {
     const subject = callee.getExpression();
-    return import_ts_morph51.Node.isIdentifier(subject) ? subject : null;
+    return import_ts_morph52.Node.isIdentifier(subject) ? subject : null;
   }
   return null;
 }
 function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom) {
-  if (!import_ts_morph51.Node.isCallExpression(node) && !import_ts_morph51.Node.isNewExpression(node)) {
+  if (!import_ts_morph52.Node.isCallExpression(node) && !import_ts_morph52.Node.isNewExpression(node)) {
     return null;
   }
-  if (import_ts_morph51.Node.isNewExpression(node) && returnPositionOf(node) === null) {
+  if (import_ts_morph52.Node.isNewExpression(node) && returnPositionOf(node) === null) {
     return null;
   }
   const callee = node.getExpression();
@@ -11990,9 +11996,9 @@ function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom)
 }
 
 // src/terminals/throws.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 function tryMatchThrowExpression(node, pattern, match, resolution) {
-  if (!import_ts_morph52.Node.isThrowStatement(node)) {
+  if (!import_ts_morph53.Node.isThrowStatement(node)) {
     return null;
   }
   const thrownExpr = node.getExpression();
@@ -12034,17 +12040,17 @@ function extractThrowMessage(callArgs) {
     return null;
   }
   for (const arg of callArgs) {
-    if (import_ts_morph52.Node.isStringLiteral(arg) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(arg)) {
+    if (import_ts_morph53.Node.isStringLiteral(arg) || import_ts_morph53.Node.isNoSubstitutionTemplateLiteral(arg)) {
       return arg.getLiteralValue();
     }
-    if (import_ts_morph52.Node.isTemplateExpression(arg)) {
+    if (import_ts_morph53.Node.isTemplateExpression(arg)) {
       return arg.getText();
     }
   }
   return null;
 }
 function classifyThrownExpression(thrown, constructorPattern) {
-  if (import_ts_morph52.Node.isCallExpression(thrown) || import_ts_morph52.Node.isNewExpression(thrown)) {
+  if (import_ts_morph53.Node.isCallExpression(thrown) || import_ts_morph53.Node.isNewExpression(thrown)) {
     const calleeText = thrown.getExpression().getText();
     if (constructorPattern !== void 0 && !calleeText.startsWith(constructorPattern)) {
       return null;
@@ -12131,9 +12137,9 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, origi
       }
     }
   });
-  if (results.length === 0 && import_ts_morph53.Node.isArrowFunction(func)) {
+  if (results.length === 0 && import_ts_morph54.Node.isArrowFunction(func)) {
     const body = func.getBody();
-    if (body !== void 0 && !import_ts_morph53.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph54.Node.isBlock(body)) {
       for (const pattern of patterns) {
         let found = null;
         if (pattern.match.type === "parameterMethodCall") {
@@ -12168,7 +12174,7 @@ function functionMayFallThrough(func) {
   if (body === void 0) {
     return false;
   }
-  if (!import_ts_morph53.Node.isBlock(body)) {
+  if (!import_ts_morph54.Node.isBlock(body)) {
     return false;
   }
   const statements = body.getStatements();
@@ -12176,7 +12182,7 @@ function functionMayFallThrough(func) {
     return true;
   }
   const last = statements[statements.length - 1];
-  if (import_ts_morph53.Node.isReturnStatement(last) || import_ts_morph53.Node.isThrowStatement(last)) {
+  if (import_ts_morph54.Node.isReturnStatement(last) || import_ts_morph54.Node.isThrowStatement(last)) {
     return false;
   }
   return true;
@@ -12224,7 +12230,7 @@ function writesTerminal(call, terminalNodes) {
   }
 }
 function isReceiverOf(node, parent) {
-  return (import_ts_morph54.Node.isPropertyAccessExpression(parent) || import_ts_morph54.Node.isElementAccessExpression(parent) || import_ts_morph54.Node.isCallExpression(parent)) && parent.getExpression() === node;
+  return (import_ts_morph55.Node.isPropertyAccessExpression(parent) || import_ts_morph55.Node.isElementAccessExpression(parent) || import_ts_morph55.Node.isCallExpression(parent)) && parent.getExpression() === node;
 }
 var isDefaultConditionList = (conditions) => conditions.length === 0 || conditions.every(
   (c) => c.source === "earlyReturn" || c.source === "earlyThrow"
@@ -12234,7 +12240,7 @@ function bodyContentOf(func) {
   if (body === void 0) {
     return "absent";
   }
-  if (!import_ts_morph54.Node.isBlock(body)) {
+  if (!import_ts_morph55.Node.isBlock(body)) {
     return "statements";
   }
   return body.getStatements().length === 0 ? "empty" : "statements";
@@ -12250,7 +12256,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       claimed.add(source);
     }
   }
-  if (import_ts_morph54.Node.isArrowFunction(func) && import_ts_morph54.Node.isExpression(body)) {
+  if (import_ts_morph55.Node.isArrowFunction(func) && import_ts_morph55.Node.isExpression(body)) {
     return claimed.has(body) ? 0 : 1;
   }
   let unmatched = 0;
@@ -12263,7 +12269,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph54.Node.isReturnStatement(node)) {
+    if (!import_ts_morph55.Node.isReturnStatement(node)) {
       return;
     }
     if (node.getExpression() === void 0) {
@@ -12416,7 +12422,7 @@ function accountFor(site, terminalNodes, branches) {
 }
 
 // src/bootstrap/sourceFileLookup.ts
-var import_ts_morph55 = require("ts-morph");
+var import_ts_morph56 = require("ts-morph");
 function createSourceFileLookup(project) {
   const all = project.getSourceFiles();
   const byAbs = /* @__PURE__ */ new Map();
@@ -12478,7 +12484,7 @@ function spanKey(span) {
 function indexFunctions(sf) {
   const index = /* @__PURE__ */ new Map();
   sf.forEachDescendant((node) => {
-    if (!import_ts_morph55.Node.isFunctionDeclaration(node) && !import_ts_morph55.Node.isFunctionExpression(node) && !import_ts_morph55.Node.isArrowFunction(node) && !import_ts_morph55.Node.isMethodDeclaration(node)) {
+    if (!import_ts_morph56.Node.isFunctionDeclaration(node) && !import_ts_morph56.Node.isFunctionExpression(node) && !import_ts_morph56.Node.isArrowFunction(node) && !import_ts_morph56.Node.isMethodDeclaration(node)) {
       return;
     }
     const bySpan = spanKey({ start: node.getStart(), end: node.getEnd() });
@@ -12492,13 +12498,13 @@ function indexFunctions(sf) {
 }
 
 // src/contract.ts
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 function extractDeclaredBody(node) {
   if (node === void 0) {
     return null;
   }
-  if (!import_ts_morph56.Node.isCallExpression(node)) {
+  if (!import_ts_morph57.Node.isCallExpression(node)) {
     return null;
   }
   const typeArgs = node.getTypeArguments();
@@ -12512,10 +12518,10 @@ function resolveHandlerPropNode(func) {
   if (parent === void 0) {
     return null;
   }
-  if (import_ts_morph56.Node.isPropertyAssignment(parent)) {
+  if (import_ts_morph57.Node.isPropertyAssignment(parent)) {
     return parent;
   }
-  if (import_ts_morph56.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph57.Node.isMethodDeclaration(func)) {
     return func;
   }
   return null;
@@ -12527,11 +12533,11 @@ function findRouterCall(unit) {
     return null;
   }
   const handlersObj = propNode.getParent();
-  if (handlersObj === void 0 || !import_ts_morph56.Node.isObjectLiteralExpression(handlersObj)) {
+  if (handlersObj === void 0 || !import_ts_morph57.Node.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
   const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !import_ts_morph56.Node.isCallExpression(routerCall)) {
+  if (routerCall === void 0 || !import_ts_morph57.Node.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -12544,17 +12550,17 @@ function findRouterCall(unit) {
   };
 }
 function resolveContractObject(contractArg, resolution) {
-  if (import_ts_morph56.Node.isObjectLiteralExpression(contractArg)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(contractArg)) {
     return contractArg;
   }
-  if (import_ts_morph56.Node.isPropertyAccessExpression(contractArg)) {
+  if (import_ts_morph57.Node.isPropertyAccessExpression(contractArg)) {
     const base = resolveContractObject(contractArg.getExpression(), resolution);
-    if (base === null || !import_ts_morph56.Node.isObjectLiteralExpression(base)) {
+    if (base === null || !import_ts_morph57.Node.isObjectLiteralExpression(base)) {
       return null;
     }
     const propName = contractArg.getName();
     for (const prop of base.getProperties()) {
-      if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
         continue;
       }
       if (prop.getName() !== propName) {
@@ -12564,20 +12570,20 @@ function resolveContractObject(contractArg, resolution) {
       if (value === void 0) {
         return null;
       }
-      if (import_ts_morph56.Node.isObjectLiteralExpression(value)) {
+      if (import_ts_morph57.Node.isObjectLiteralExpression(value)) {
         return value;
       }
-      if (import_ts_morph56.Node.isIdentifier(value) || import_ts_morph56.Node.isPropertyAccessExpression(value)) {
+      if (import_ts_morph57.Node.isIdentifier(value) || import_ts_morph57.Node.isPropertyAccessExpression(value)) {
         return resolveContractObject(value, resolution);
       }
-      if (import_ts_morph56.Node.isCallExpression(value)) {
+      if (import_ts_morph57.Node.isCallExpression(value)) {
         return unwrapContractInit(value);
       }
       return null;
     }
     return null;
   }
-  if (!import_ts_morph56.Node.isIdentifier(contractArg)) {
+  if (!import_ts_morph57.Node.isIdentifier(contractArg)) {
     return null;
   }
   const symbol = contractArg.getSymbol();
@@ -12589,7 +12595,7 @@ function resolveContractObject(contractArg, resolution) {
     return null;
   }
   const decl = decls[0];
-  if (import_ts_morph56.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph57.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sourceFile = importDecl.getModuleSpecifierSourceFile();
     if (sourceFile !== void 0 && resolution !== void 0) {
@@ -12598,14 +12604,14 @@ function resolveContractObject(contractArg, resolution) {
       );
       if (exported !== void 0 && exported.length > 0) {
         const exportedDecl = exported[0];
-        if (import_ts_morph56.Node.isVariableDeclaration(exportedDecl)) {
+        if (import_ts_morph57.Node.isVariableDeclaration(exportedDecl)) {
           return unwrapContractInit(exportedDecl.getInitializer());
         }
       }
     }
     return null;
   }
-  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
     return unwrapContractInit(decl.getInitializer());
   }
   return null;
@@ -12615,39 +12621,39 @@ function unwrapContractInit(init) {
     return null;
   }
   const node = peelSyntax(init);
-  if (import_ts_morph56.Node.isCallExpression(node)) {
+  if (import_ts_morph57.Node.isCallExpression(node)) {
     const args = node.getArguments();
-    if (args.length > 0 && import_ts_morph56.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length > 0 && import_ts_morph57.Node.isObjectLiteralExpression(args[0])) {
       return args[0];
     }
     return null;
   }
-  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
     return node;
   }
   return null;
 }
 function extractEndpointContract(endpointNode, pattern, framework, resolution) {
-  if (!import_ts_morph56.Node.isObjectLiteralExpression(endpointNode)) {
+  if (!import_ts_morph57.Node.isObjectLiteralExpression(endpointNode)) {
     return null;
   }
   const responses = [];
   let method;
   let path14;
   for (const prop of endpointNode.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const propName = prop.getName();
     if (propName === pattern.methodProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
         method = val.getLiteralValue();
       }
     }
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
         path14 = val.getLiteralValue();
       }
     }
@@ -12656,7 +12662,7 @@ function extractEndpointContract(endpointNode, pattern, framework, resolution) {
       const val = written === void 0 ? null : objectLiteralOf(written, resolution);
       if (val !== null) {
         for (const respProp of propertiesOf(val, resolution)) {
-          if (!import_ts_morph56.Node.isPropertyAssignment(respProp)) {
+          if (!import_ts_morph57.Node.isPropertyAssignment(respProp)) {
             continue;
           }
           const statusStr = respProp.getName();
@@ -12706,11 +12712,11 @@ function readContract(unit, pattern, framework, resolution) {
     return null;
   }
   const contractObj = resolveContractObject(routerInfo.contractArg, resolution);
-  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== routerInfo.handlerName) {
@@ -12735,7 +12741,7 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   const call = func.getParent();
-  if (call === void 0 || !import_ts_morph56.Node.isCallExpression(call)) {
+  if (call === void 0 || !import_ts_morph57.Node.isCallExpression(call)) {
     return null;
   }
   const args = call.getArguments();
@@ -12747,24 +12753,24 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   let node = arg;
-  while (import_ts_morph56.Node.isAsExpression(node)) {
+  while (import_ts_morph57.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
-  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
     return node;
   }
-  if (import_ts_morph56.Node.isCallExpression(node)) {
+  if (import_ts_morph57.Node.isCallExpression(node)) {
     return unwrapContractInit(node);
   }
   return resolveContractObject(node, resolution);
 }
 function readContractForClientCall(callExpression, methodName, pattern, framework, resolution) {
-  const callee = import_ts_morph56.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
-  if (callee === null || !import_ts_morph56.Node.isPropertyAccessExpression(callee)) {
+  const callee = import_ts_morph57.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
+  if (callee === null || !import_ts_morph57.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   const clientIdentifier = callee.getExpression();
-  if (!import_ts_morph56.Node.isIdentifier(clientIdentifier)) {
+  if (!import_ts_morph57.Node.isIdentifier(clientIdentifier)) {
     return null;
   }
   const symbol = clientIdentifier.getSymbol();
@@ -12776,11 +12782,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const decl = decls[0];
-  if (!import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (!import_ts_morph57.Node.isVariableDeclaration(decl)) {
     return null;
   }
   const init = decl.getInitializer();
-  if (init === void 0 || !import_ts_morph56.Node.isCallExpression(init)) {
+  if (init === void 0 || !import_ts_morph57.Node.isCallExpression(init)) {
     return null;
   }
   const args = init.getArguments();
@@ -12788,11 +12794,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const contractObj = resolveContractObject(args[0], resolution);
-  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== methodName) {
@@ -12888,7 +12894,7 @@ function parameterName(segment, convention) {
 
 // src/discovery/graphqlClientConstruction.ts
 var import_picomatch2 = __toESM(require("picomatch"), 1);
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
 function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const scopes = compileOperationScopes(packs);
@@ -13036,7 +13042,7 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheConstruction === null) {
     return "unknown";
   }
-  if (!import_ts_morph57.Node.isNewExpression(cacheConstruction) && !import_ts_morph57.Node.isCallExpression(cacheConstruction)) {
+  if (!import_ts_morph58.Node.isNewExpression(cacheConstruction) && !import_ts_morph58.Node.isCallExpression(cacheConstruction)) {
     return "unknown";
   }
   const args = cacheConstruction.getArguments();
@@ -13050,15 +13056,15 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheOptions.getProperty(spec.registryProperty) !== void 0) {
     return "configured";
   }
-  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph57.Node.isSpreadAssignment(property));
+  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph58.Node.isSpreadAssignment(property));
   return hasSpread ? "unknown" : "absent";
 }
 function firstArgumentObjectLiteral(construction) {
-  if (!import_ts_morph57.Node.isNewExpression(construction) && !import_ts_morph57.Node.isCallExpression(construction)) {
+  if (!import_ts_morph58.Node.isNewExpression(construction) && !import_ts_morph58.Node.isCallExpression(construction)) {
     return null;
   }
   const arg = construction.getArguments()[0];
-  if (arg === void 0 || !import_ts_morph57.Node.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(arg)) {
     return null;
   }
   return arg;
@@ -13068,10 +13074,10 @@ function propertyValueOf2(options, name) {
   if (property === void 0) {
     return null;
   }
-  if (import_ts_morph57.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph58.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph57.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph58.Node.isShorthandPropertyAssignment(property)) {
     const symbol = property.getProject().getTypeChecker().getShorthandAssignmentValueSymbol(property);
     return symbol?.getValueDeclaration() ?? null;
   }
@@ -13081,13 +13087,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_morph57.Node.isVariableDeclaration(current2)) {
+    if (import_ts_morph58.Node.isVariableDeclaration(current2)) {
       current2 = current2.getInitializer();
       continue;
     }
-    if (import_ts_morph57.Node.isNewExpression(current2) || import_ts_morph57.Node.isCallExpression(current2)) {
+    if (import_ts_morph58.Node.isNewExpression(current2) || import_ts_morph58.Node.isCallExpression(current2)) {
       const callee = current2.getExpression();
-      if (callee === void 0 || !import_ts_morph57.Node.isIdentifier(callee)) {
+      if (callee === void 0 || !import_ts_morph58.Node.isIdentifier(callee)) {
         return null;
       }
       const local = localImportName(
@@ -13097,11 +13103,11 @@ function resolveToConstructionOf(expression, cacheClass) {
       );
       return local !== null && callee.getText() === local ? current2 : null;
     }
-    if (!import_ts_morph57.Node.isIdentifier(current2)) {
+    if (!import_ts_morph58.Node.isIdentifier(current2)) {
       return null;
     }
     const declaration = current2.getSymbol()?.getValueDeclaration();
-    if (declaration === void 0 || !import_ts_morph57.Node.isVariableDeclaration(declaration)) {
+    if (declaration === void 0 || !import_ts_morph58.Node.isVariableDeclaration(declaration)) {
       return null;
     }
     current2 = declaration.getInitializer();
@@ -13112,11 +13118,11 @@ function unwrapExpression2(node) {
   return peelSyntax(node);
 }
 function isConstructionNamed(node, localName) {
-  if (!import_ts_morph57.Node.isNewExpression(node) && !import_ts_morph57.Node.isCallExpression(node)) {
+  if (!import_ts_morph58.Node.isNewExpression(node) && !import_ts_morph58.Node.isCallExpression(node)) {
     return false;
   }
   const callee = node.getExpression();
-  return callee !== void 0 && import_ts_morph57.Node.isIdentifier(callee) && callee.getText() === localName;
+  return callee !== void 0 && import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function localImportName(sourceFile, importModule, importName) {
   for (const one of namedImportsOf(sourceFile, [importModule], {
@@ -13130,11 +13136,11 @@ function localImportName(sourceFile, importModule, importName) {
 }
 function constructionRef(node, uriProperty, resolution) {
   const optionsArg = node.getArguments()[0];
-  if (optionsArg === void 0 || !import_ts_morph57.Node.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(optionsArg)) {
     return null;
   }
   const property = optionsArg.getProperty(uriProperty);
-  if (property === void 0 || !import_ts_morph57.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph58.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
@@ -13149,10 +13155,10 @@ function constructionRef(node, uriProperty, resolution) {
 }
 
 // src/discovery/helperIndex.ts
-var import_ts_morph59 = require("ts-morph");
+var import_ts_morph60 = require("ts-morph");
 
 // src/discovery/helperReading.ts
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 var UNREAD = { as: "unread" };
 function readHelperSinks(helper) {
   const positions = parameterPositions(helper);
@@ -13162,11 +13168,11 @@ function readHelperSinks(helper) {
     return sinks;
   }
   body.forEachDescendant((node) => {
-    if (!import_ts_morph58.Node.isCallExpression(node)) {
+    if (!import_ts_morph59.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    const [method, receiver] = import_ts_morph58.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
+    const [method, receiver] = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
     sinks.push({
       method,
       receiver,
@@ -13186,25 +13192,25 @@ function parameterPositions(helper) {
   return positions;
 }
 function readValue(node, positions) {
-  if (import_ts_morph58.Node.isStringLiteral(node) || import_ts_morph58.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph59.Node.isStringLiteral(node) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { as: "text", text: node.getLiteralValue() };
   }
-  if (import_ts_morph58.Node.isTemplateExpression(node)) {
+  if (import_ts_morph59.Node.isTemplateExpression(node)) {
     return templateText(node, positions);
   }
-  if (import_ts_morph58.Node.isIdentifier(node)) {
+  if (import_ts_morph59.Node.isIdentifier(node)) {
     const position = positions.get(node.getText());
     return position === void 0 ? UNREAD : { as: "parameter", position };
   }
-  if (import_ts_morph58.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph59.Node.isPropertyAccessExpression(node)) {
     const target = node.getExpression();
-    const position = import_ts_morph58.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
+    const position = import_ts_morph59.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
     return position === void 0 ? UNREAD : { as: "parameter", position, property: node.getName() };
   }
-  if (import_ts_morph58.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph59.Node.isObjectLiteralExpression(node)) {
     return objectValue(node, positions);
   }
-  if (import_ts_morph58.Node.isCallExpression(node)) {
+  if (import_ts_morph59.Node.isCallExpression(node)) {
     return {
       as: "call",
       callee: node.getExpression().getText(),
@@ -13214,13 +13220,13 @@ function readValue(node, positions) {
   return UNREAD;
 }
 function templateText(node, positions) {
-  if (!import_ts_morph58.Node.isTemplateExpression(node)) {
+  if (!import_ts_morph59.Node.isTemplateExpression(node)) {
     return UNREAD;
   }
   let text = node.getHead().getLiteralText();
   for (const span of node.getTemplateSpans()) {
     const expression = span.getExpression();
-    const position = import_ts_morph58.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
+    const position = import_ts_morph59.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
     if (position === void 0) {
       return UNREAD;
     }
@@ -13229,12 +13235,12 @@ function templateText(node, positions) {
   return { as: "text", text };
 }
 function objectValue(node, positions) {
-  if (!import_ts_morph58.Node.isObjectLiteralExpression(node)) {
+  if (!import_ts_morph59.Node.isObjectLiteralExpression(node)) {
     return UNREAD;
   }
   const properties = {};
   for (const property of node.getProperties()) {
-    if (!import_ts_morph58.Node.isPropertyAssignment(property)) {
+    if (!import_ts_morph59.Node.isPropertyAssignment(property)) {
       continue;
     }
     const initializer = property.getInitializer();
@@ -13249,7 +13255,7 @@ function objectValue(node, positions) {
   return { as: "object", properties };
 }
 function propertyKey(name) {
-  return import_ts_morph58.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
+  return import_ts_morph59.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
 }
 
 // src/discovery/helperIndex.ts
@@ -13379,11 +13385,11 @@ function registrationMatchesOf(pack) {
 }
 function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   sourceFile.forEachDescendant((node) => {
-    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)) {
+    if (!import_ts_morph60.Node.isIdentifier(callee)) {
       return;
     }
     const handedOver = subjectArgument(node, subjects, match, resolution);
@@ -13398,12 +13404,12 @@ function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   });
 }
 function subjectArgument(call, subjects, match, resolution) {
-  if (!import_ts_morph59.Node.isCallExpression(call)) {
+  if (!import_ts_morph60.Node.isCallExpression(call)) {
     return -1;
   }
   const args = call.getArguments();
   for (const [position, argument] of args.entries()) {
-    if (!import_ts_morph59.Node.isIdentifier(argument) && !import_ts_morph59.Node.isPropertyAccessExpression(argument)) {
+    if (!import_ts_morph60.Node.isIdentifier(argument) && !import_ts_morph60.Node.isPropertyAccessExpression(argument)) {
       continue;
     }
     if (subjectNodeFor(argument, subjects, match, resolution) !== void 0) {
@@ -13464,7 +13470,7 @@ function declaredFunctions(sourceFile) {
   }
   for (const variable4 of sourceFile.getVariableDeclarations()) {
     const initializer = variable4.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph59.Node.isArrowFunction(initializer) || import_ts_morph59.Node.isFunctionExpression(initializer))) {
+    if (initializer !== void 0 && (import_ts_morph60.Node.isArrowFunction(initializer) || import_ts_morph60.Node.isFunctionExpression(initializer))) {
       found.push([variable4.getName(), initializer]);
     }
   }
@@ -13557,7 +13563,7 @@ function recordEdge(edgesByChild, candidate) {
 }
 
 // src/discovery/wrapperIndex.ts
-var import_ts_morph60 = require("ts-morph");
+var import_ts_morph61 = require("ts-morph");
 var import_resolution6 = require("@suss/resolution");
 var NO_WRAPPERS = {
   wrappersFor: () => [],
@@ -13681,11 +13687,11 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
   const candidates = [];
   const unresolved = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph60.Node.isCallExpression(node)) {
+    if (!import_ts_morph61.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph60.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
+    if (!import_ts_morph61.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -13780,7 +13786,7 @@ function discoverConstructorOptions(sourceFile, pattern, wraps, subjects, resolu
   return { candidates, unresolved };
 }
 function constructorOptionOf(construction, wraps, resolution) {
-  if (!(import_ts_morph60.Node.isNewExpression(construction) || import_ts_morph60.Node.isCallExpression(construction))) {
+  if (!(import_ts_morph61.Node.isNewExpression(construction) || import_ts_morph61.Node.isCallExpression(construction))) {
     return void 0;
   }
   const optionsArg = construction.getArguments()[wraps.targetPosition];
@@ -13820,21 +13826,21 @@ function labelFor(targetArg, wraps) {
 }
 function factoryNameOf(targetArg) {
   const written = factKeyOf(targetArg);
-  if (!import_ts_morph60.Node.isCallExpression(written)) {
+  if (!import_ts_morph61.Node.isCallExpression(written)) {
     return void 0;
   }
   const callee = written.getExpression();
-  if (import_ts_morph60.Node.isIdentifier(callee)) {
+  if (import_ts_morph61.Node.isIdentifier(callee)) {
     return callee.getText();
   }
-  if (import_ts_morph60.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph61.Node.isPropertyAccessExpression(callee)) {
     return callee.getName();
   }
   return void 0;
 }
 function factoryStopOf(targetArg) {
   const written = factKeyOf(targetArg);
-  if (!import_ts_morph60.Node.isCallExpression(written)) {
+  if (!import_ts_morph61.Node.isCallExpression(written)) {
     return null;
   }
   const callee = factoryNameOf(targetArg);
@@ -13865,7 +13871,7 @@ function scopeOf(args, wraps, resolution) {
 }
 
 // src/discoveryContext.ts
-var import_ts_morph61 = require("ts-morph");
+var import_ts_morph62 = require("ts-morph");
 function createTsDiscoveryContext(resolution) {
   const store = resolution ?? new ResolutionStore();
   return {
@@ -13900,7 +13906,7 @@ function exportedFunctions(sourceFile, resolution) {
   return out;
 }
 function exportedFunction(decl, resolution) {
-  const writtenAgain = import_ts_morph61.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
+  const writtenAgain = import_ts_morph62.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
   if (!writtenAgain) {
     const declared = resolveDeclarationToFunction(decl);
     if (declared !== null) {
@@ -13921,7 +13927,7 @@ function valueToAskAbout(decl, writtenAgain) {
   if (writtenAgain) {
     return decl;
   }
-  const value = import_ts_morph61.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
+  const value = import_ts_morph62.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
   return couldStillNameAFunction(value) ? value : null;
 }
 function resolveDeclarationToFunction(decl) {
@@ -13929,18 +13935,18 @@ function resolveDeclarationToFunction(decl) {
   if (fn !== null) {
     return fn;
   }
-  if (import_ts_morph61.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph62.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph61.Node.isArrowFunction(init) || import_ts_morph61.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph62.Node.isArrowFunction(init) || import_ts_morph62.Node.isFunctionExpression(init))) {
       return init;
     }
   }
   return null;
 }
 function hasJsxReturn(func) {
-  if (import_ts_morph61.Node.isArrowFunction(func)) {
+  if (import_ts_morph62.Node.isArrowFunction(func)) {
     const body2 = func.getBody();
-    if (import_ts_morph61.Node.isExpression(body2) && isJsxOrFragment(body2)) {
+    if (import_ts_morph62.Node.isExpression(body2) && isJsxOrFragment(body2)) {
       return true;
     }
   }
@@ -13954,11 +13960,11 @@ function hasJsxReturn(func) {
       traversal.stop();
       return;
     }
-    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))) {
+    if (node !== func && (import_ts_morph62.Node.isFunctionDeclaration(node) || import_ts_morph62.Node.isFunctionExpression(node) || import_ts_morph62.Node.isArrowFunction(node) || import_ts_morph62.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph61.Node.isReturnStatement(node)) {
+    if (import_ts_morph62.Node.isReturnStatement(node)) {
       const expr = node.getExpression();
       if (expr !== void 0 && isJsxOrFragment(expr)) {
         found = true;
@@ -13969,7 +13975,7 @@ function hasJsxReturn(func) {
 }
 function isJsxOrFragment(node) {
   const current2 = peelParens(node);
-  return import_ts_morph61.Node.isJsxElement(current2) || import_ts_morph61.Node.isJsxSelfClosingElement(current2) || import_ts_morph61.Node.isJsxFragment(current2);
+  return import_ts_morph62.Node.isJsxElement(current2) || import_ts_morph62.Node.isJsxSelfClosingElement(current2) || import_ts_morph62.Node.isJsxFragment(current2);
 }
 
 // src/graphqlContract.ts
@@ -14215,7 +14221,7 @@ function deriveBoundaryEffects(summaries, facts) {
 }
 
 // src/resolve/reachableClosure.ts
-var import_ts_morph62 = require("ts-morph");
+var import_ts_morph63 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor7 = require("@suss/extractor");
@@ -14248,7 +14254,7 @@ function targetOf(node) {
   };
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph62.Node.isCallExpression(call)) {
+  if (!import_ts_morph63.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -14261,7 +14267,7 @@ function resolveCallee(call, calleeName, scan) {
     }
   }
   const resolveSources = scan.resolveCallableSources;
-  if (resolveSources !== void 0 && import_ts_morph62.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+  if (resolveSources !== void 0 && import_ts_morph63.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);
@@ -14307,11 +14313,11 @@ function passedPositionKey(target, position) {
   return `${offsetKeyFor(target.file, target.span)}#${position}`;
 }
 function resolveJsxReference(node, scan) {
-  if (!import_ts_morph62.Node.isJsxOpeningElement(node) && !import_ts_morph62.Node.isJsxSelfClosingElement(node)) {
+  if (!import_ts_morph63.Node.isJsxOpeningElement(node) && !import_ts_morph63.Node.isJsxSelfClosingElement(node)) {
     return null;
   }
   const tag = node.getTagNameNode();
-  if (!import_ts_morph62.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
+  if (!import_ts_morph63.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
     return null;
   }
   const name = tag.getText();
@@ -14357,12 +14363,12 @@ function collectReachable(func, scan) {
     candidates.push(outcome.candidate);
   };
   const recordPassedArgs = (call, calleeText, calleeOutcome) => {
-    if (!import_ts_morph62.Node.isCallExpression(call)) {
+    if (!import_ts_morph63.Node.isCallExpression(call)) {
       return;
     }
     const calleeTarget = declaredAtOf(calleeOutcome);
     call.getArguments().forEach((arg, position) => {
-      if (!import_ts_morph62.Node.isIdentifier(arg)) {
+      if (!import_ts_morph63.Node.isIdentifier(arg)) {
         return;
       }
       const resolved = functionTargetOf(arg);
@@ -14382,7 +14388,7 @@ function collectReachable(func, scan) {
       record2(jsx.outcome);
       return;
     }
-    if (!import_ts_morph62.Node.isCallExpression(node)) {
+    if (!import_ts_morph63.Node.isCallExpression(node)) {
       return;
     }
     const calleeText = normalizeCallee(node.getExpression().getText());
@@ -14468,7 +14474,7 @@ function recognizerOnlyRoots(packsByFile) {
       }
       for (const declaration of variableStatement.getDeclarations()) {
         const init = declaration.getInitializer();
-        if (init !== void 0 && (import_ts_morph62.Node.isArrowFunction(init) || import_ts_morph62.Node.isFunctionExpression(init)) && hasBody(init)) {
+        if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init)) && hasBody(init)) {
           roots.push({ func: init, name: declaration.getName() });
         }
       }
@@ -14722,7 +14728,7 @@ function recordParameterGaps(parameterCallsByKey, summariesByKey, passedPosition
 }
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph63 = require("ts-morph");
+var import_ts_morph64 = require("ts-morph");
 var import_datalog5 = require("@suss/datalog");
 var RETHROW_RULES = [
   (0, import_datalog5.rule)(
@@ -14859,7 +14865,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph63.Node.isThrowStatement(node)) {
+    if (!import_ts_morph64.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -14869,7 +14875,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph63.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph64.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -14879,13 +14885,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph63.Node.isCatchClause(current2)) {
+    if (import_ts_morph64.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph63.Node.isTryStatement(current2)) {
+    if (import_ts_morph64.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph63.Node.isFunctionDeclaration(current2) || import_ts_morph63.Node.isFunctionExpression(current2) || import_ts_morph63.Node.isArrowFunction(current2) || import_ts_morph63.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph64.Node.isFunctionDeclaration(current2) || import_ts_morph64.Node.isFunctionExpression(current2) || import_ts_morph64.Node.isArrowFunction(current2) || import_ts_morph64.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -14893,14 +14899,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph63.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph64.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph63.Node.isCallExpression(node)) {
+    if (!import_ts_morph64.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -14917,7 +14923,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph63.Node.isCallExpression(call)) {
+  if (!import_ts_morph64.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -14947,12 +14953,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph63.Node.isFunctionDeclaration(decl) || import_ts_morph63.Node.isFunctionExpression(decl) || import_ts_morph63.Node.isArrowFunction(decl) || import_ts_morph63.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph64.Node.isFunctionDeclaration(decl) || import_ts_morph64.Node.isFunctionExpression(decl) || import_ts_morph64.Node.isArrowFunction(decl) || import_ts_morph64.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph63.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph64.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph64.Node.isArrowFunction(init) || import_ts_morph64.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -14960,22 +14966,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph64 = require("ts-morph");
+var import_ts_morph65 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph64.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph65.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph64.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph65.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph64.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph65.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph64.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph65.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -14996,11 +15002,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph64.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph65.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph64.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph65.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -15032,7 +15038,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph64.Node.isCallExpression(node)) {
+  if (import_ts_morph65.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -15064,14 +15070,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph64.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph65.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_morph64.Node.isArrowFunction(callback) || import_ts_morph64.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph65.Node.isArrowFunction(callback) || import_ts_morph65.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -15079,11 +15085,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph64.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph65.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap(expr) {
   let node = expr;
-  while (import_ts_morph64.Node.isAwaitExpression(node) || import_ts_morph64.Node.isParenthesizedExpression(node) || import_ts_morph64.Node.isAsExpression(node)) {
+  while (import_ts_morph65.Node.isAwaitExpression(node) || import_ts_morph65.Node.isParenthesizedExpression(node) || import_ts_morph65.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -15093,15 +15099,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph64.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph65.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph64.Node.isExpression(expr) ? unwrap(expr) : expr;
-  if (import_ts_morph64.Node.isCallExpression(node)) {
+  let node = import_ts_morph65.Node.isExpression(expr) ? unwrap(expr) : expr;
+  if (import_ts_morph65.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph64.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph65.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -15120,16 +15126,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph64.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph65.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph64.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph64.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph65.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -15140,7 +15146,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph64.Node.isIdentifier(node)) {
+    if (!import_ts_morph65.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -15152,13 +15158,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph64.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph65.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph64.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -15172,15 +15178,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph64.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph65.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph64.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph65.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph64.Node.isFunctionLikeDeclaration(current2) || import_ts_morph64.Node.isVariableStatement(current2)) {
+    if (import_ts_morph65.Node.isFunctionLikeDeclaration(current2) || import_ts_morph65.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -15243,7 +15249,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph64.Node.isIfStatement(parent)) {
+    if (import_ts_morph65.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -15305,7 +15311,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph65 = require("ts-morph");
+var import_ts_morph66 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -15332,18 +15338,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph65.Node.isJsxOpeningElement(node) && !import_ts_morph65.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph66.Node.isJsxOpeningElement(node) && !import_ts_morph66.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph65.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph66.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph65.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph66.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -15366,11 +15372,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph65.Node.isCallExpression(node)) {
+    if (!import_ts_morph66.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph65.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph66.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -15381,10 +15387,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph65.Node.isArrowFunction(expr) || import_ts_morph65.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph66.Node.isArrowFunction(expr) || import_ts_morph66.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph65.Node.isIdentifier(expr)) {
+  if (import_ts_morph66.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -15403,15 +15409,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph65.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph66.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph65.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph66.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph65.Node.isArrowFunction(init) || import_ts_morph65.Node.isFunctionExpression(init)) {
+    if (import_ts_morph66.Node.isArrowFunction(init) || import_ts_morph66.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -15432,7 +15438,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph65.Node.isArrowFunction(arg) || import_ts_morph65.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph66.Node.isArrowFunction(arg) || import_ts_morph66.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -15444,7 +15450,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph65.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph66.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -15693,13 +15699,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph66.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph66.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph67.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph66.Node.isOmittedExpression(element)) {
+      if (import_ts_morph67.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -15729,7 +15735,7 @@ function objectParamInputs(param, position, mapping) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph66.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -15759,7 +15765,7 @@ function bindingRole(element, name) {
   if (property === void 0) {
     return name;
   }
-  if (import_ts_morph66.Node.isStringLiteral(property)) {
+  if (import_ts_morph67.Node.isStringLiteral(property)) {
     return property.getLiteralValue();
   }
   return property.getText();
@@ -15791,7 +15797,7 @@ function extractParameters(func, inputMapping) {
       const param = params[i];
       const nameNode = param.getNameNode();
       const boundNames = bindingPatternNames(nameNode);
-      if (import_ts_morph66.Node.isObjectBindingPattern(nameNode)) {
+      if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
         for (const element of nameNode.getElements()) {
           result.push({
             name: element.getName(),
@@ -15858,7 +15864,7 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph66.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph67.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -15867,19 +15873,19 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph66.Node.isAwaitExpression(init)) {
+    if (import_ts_morph67.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph66.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph67.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph66.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph67.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph66.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph67.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -16796,9 +16802,9 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(import_ts_morph66.SyntaxKind.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(import_ts_morph67.SyntaxKind.CallExpression)) {
     const first = call.getArguments()[0];
-    if (first === void 0 || !import_ts_morph66.Node.isIdentifier(first)) {
+    if (first === void 0 || !import_ts_morph67.Node.isIdentifier(first)) {
       continue;
     }
     const at = names.indexOf(first.getText());
@@ -16847,16 +16853,16 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph66.Node.isFunctionDeclaration(func) || import_ts_morph66.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph66.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph67.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph66.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph66.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -16865,10 +16871,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph66.Node.isCallExpression(current2)) {
+    if (import_ts_morph67.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph66.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph67.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -16879,7 +16885,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph66.Node.isFunctionDeclaration(current2) || import_ts_morph66.Node.isFunctionExpression(current2) || import_ts_morph66.Node.isArrowFunction(current2) || import_ts_morph66.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph67.Node.isFunctionDeclaration(current2) || import_ts_morph67.Node.isFunctionExpression(current2) || import_ts_morph67.Node.isArrowFunction(current2) || import_ts_morph67.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -16887,13 +16893,13 @@ function enclosingFunction(node) {
   return null;
 }
 function callerName(func) {
-  if (import_ts_morph66.Node.isFunctionDeclaration(func) || import_ts_morph66.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph66.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph66.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -16992,7 +16998,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_morph66.Project(
+  const project = config.project ?? new import_ts_morph67.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -17708,7 +17714,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path11 = __toESM(require("path"), 1);
-var import_ts_morph67 = require("ts-morph");
+var import_ts_morph68 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -17756,12 +17762,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph67.Project({
+  const project = new import_ts_morph68.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph67.ScriptTarget.ES2022,
-      module: import_ts_morph67.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph67.ModuleResolutionKind.Bundler,
+      target: import_ts_morph68.ScriptTarget.ES2022,
+      module: import_ts_morph68.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph68.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -17802,7 +17808,7 @@ function findNearestTsconfig(startDir) {
 
 // src/facts/why.ts
 var import_node_path12 = __toESM(require("path"), 1);
-var import_ts_morph68 = require("ts-morph");
+var import_ts_morph69 = require("ts-morph");
 var import_resolution7 = require("@suss/resolution");
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -17816,7 +17822,7 @@ var TypeScriptWhySession = 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_morph68.Project({ tsConfigFilePath: tsconfig });
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph69.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
   }
   /**
@@ -17831,7 +17837,7 @@ var TypeScriptWhySession = class {
     }
     let found = null;
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph68.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+      if (import_ts_morph69.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
         found = node;
       }
     });
@@ -17849,7 +17855,7 @@ var TypeScriptWhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      import_ts_morph68.SyntaxKind.CallExpression
+      import_ts_morph69.SyntaxKind.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -17923,21 +17929,21 @@ var TypeScriptWhySession = class {
   }
 };
 function displayNameOf(node) {
-  if (import_ts_morph68.Node.isIdentifier(node) || import_ts_morph68.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph69.Node.isIdentifier(node) || import_ts_morph69.Node.isPropertyAccessExpression(node)) {
     return node.getText();
   }
-  if (import_ts_morph68.Node.isCallExpression(node) || import_ts_morph68.Node.isNewExpression(node)) {
+  if (import_ts_morph69.Node.isCallExpression(node) || import_ts_morph69.Node.isNewExpression(node)) {
     return `${node.getExpression()?.getText() ?? "call"}(...)`;
   }
-  if (import_ts_morph68.Node.isFunctionDeclaration(node) || import_ts_morph68.Node.isClassDeclaration(node) || import_ts_morph68.Node.isMethodDeclaration(node) || import_ts_morph68.Node.isVariableDeclaration(node)) {
+  if (import_ts_morph69.Node.isFunctionDeclaration(node) || import_ts_morph69.Node.isClassDeclaration(node) || import_ts_morph69.Node.isMethodDeclaration(node) || import_ts_morph69.Node.isVariableDeclaration(node)) {
     const name = node.getName();
     if (name !== void 0) {
       return name;
     }
   }
-  if (import_ts_morph68.Node.isArrowFunction(node) || import_ts_morph68.Node.isFunctionExpression(node)) {
+  if (import_ts_morph69.Node.isArrowFunction(node) || import_ts_morph69.Node.isFunctionExpression(node)) {
     const parent = node.getParent();
-    if (parent !== void 0 && import_ts_morph68.Node.isVariableDeclaration(parent)) {
+    if (parent !== void 0 && import_ts_morph69.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
   }
@@ -17947,7 +17953,7 @@ function displayNameOf(node) {
 
 // src/stubEvidence.ts
 var import_node_path13 = __toESM(require("path"), 1);
-var import_ts_morph69 = require("ts-morph");
+var import_ts_morph70 = require("ts-morph");
 function stubEvidenceIn(project, packageName, root) {
   const resolution = new ResolutionStore();
   const byExport = /* @__PURE__ */ new Map();
@@ -17974,7 +17980,7 @@ function stubEvidenceIn(project, packageName, root) {
   );
 }
 function stubEvidence(options) {
-  const project = new import_ts_morph69.Project(
+  const project = new import_ts_morph70.Project(
     options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : { compilerOptions: { allowJs: true } }
   );
   const root = options.tsConfigFilePath !== void 0 ? import_node_path13.default.dirname(options.tsConfigFilePath) : import_node_path13.default.resolve(options.directory ?? process.cwd());