@suss/adapter-typescript 0.25.0 → 0.26.0

package/dist/index.cjs

@@ -41,7 +41,7 @@ __export(index_exports, {
   collectAncestorBranches: () => collectAncestorBranches,
   collectClientFieldAccesses: () => collectClientFieldAccesses,
   computeAdapterPacksDigest: () => computeAdapterPacksDigest,
-  computeContentHash: () => import_extractor10.computeContentHash,
+  computeContentHash: () => import_extractor11.computeContentHash,
   createProjectWithoutTsconfig: () => createProjectWithoutTsconfig,
   createTsDiscoveryContext: () => createTsDiscoveryContext,
   createTsSubUnitContext: () => createTsSubUnitContext,
@@ -81,10 +81,10 @@ var import_node_path11 = __toESM(require("path"), 1);
 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");
+var import_extractor12 = require("@suss/extractor");
 
 // src/assembly.ts
-var import_ts_morph55 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 var import_extractor5 = require("@suss/extractor");
 
 // src/conditions.ts
@@ -1544,7 +1544,7 @@ function degradedResult(func, terminalNodes, reason) {
 }
 
 // src/resolve/invocationEffects.ts
-var import_ts_morph43 = require("ts-morph");
+var import_ts_morph42 = require("ts-morph");
 var import_extractor4 = require("@suss/extractor");
 
 // src/lines.ts
@@ -2402,7 +2402,7 @@ function reportUnreadableExports(file) {
 }
 
 // src/resolve/callOps.ts
-var import_ts_morph42 = require("ts-morph");
+var import_ts_morph41 = require("ts-morph");
 
 // src/configuredCall.ts
 var import_ts_morph12 = require("ts-morph");
@@ -2460,10 +2460,10 @@ function rootIdentifier(node) {
 }
 
 // src/parameterReads.ts
-var import_ts_morph40 = require("ts-morph");
+var import_ts_morph39 = require("ts-morph");
 
 // src/resolve/functionBehind.ts
-var import_ts_morph39 = require("ts-morph");
+var import_ts_morph38 = require("ts-morph");
 
 // src/facts/store.ts
 var import_ts_morph16 = require("ts-morph");
@@ -4399,178 +4399,11 @@ function declarationOf(value) {
 }
 
 // src/discovery/clientCall.ts
-var import_ts_morph20 = require("ts-morph");
+var import_ts_morph19 = require("ts-morph");
 
 // src/discovery/importScan.ts
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/diagnostics.ts
 var import_node_path2 = __toESM(require("path"), 1);
-var import_ts_morph17 = require("ts-morph");
 var import_extractor3 = require("@suss/extractor");
-function commonDirectoryOf(files) {
-  const absolute = files.filter((f) => import_node_path2.default.isAbsolute(f));
-  const first = absolute[0];
-  if (first === void 0) {
-    return void 0;
-  }
-  let shared = import_node_path2.default.dirname(first).split(import_node_path2.default.sep);
-  for (const file of absolute.slice(1)) {
-    const parts = import_node_path2.default.dirname(file).split(import_node_path2.default.sep);
-    let i = 0;
-    while (i < shared.length && i < parts.length && shared[i] === parts[i]) {
-      i += 1;
-    }
-    shared = shared.slice(0, i);
-  }
-  const joined2 = shared.join(import_node_path2.default.sep);
-  return joined2.length > 1 ? joined2 : void 0;
-}
-var DEFAULT_RESOLUTION = {
-  moduleResolution: import_ts_morph17.ts.ModuleResolutionKind.Bundler,
-  target: import_ts_morph17.ts.ScriptTarget.ESNext,
-  module: import_ts_morph17.ts.ModuleKind.ESNext
-};
-function resolutionContext(args) {
-  if (args.tsConfigFilePath !== void 0) {
-    const configFile = import_ts_morph17.ts.readConfigFile(
-      args.tsConfigFilePath,
-      import_ts_morph17.ts.sys.readFile
-    );
-    if (configFile.error !== void 0) {
-      return null;
-    }
-    const dir = import_node_path2.default.dirname(args.tsConfigFilePath);
-    const parsed = import_ts_morph17.ts.parseJsonConfigFileContent(
-      configFile.config,
-      import_ts_morph17.ts.sys,
-      dir,
-      /*existingOptions*/
-      void 0,
-      args.tsConfigFilePath
-    );
-    return {
-      containingFile: import_node_path2.default.join(dir, "index.ts"),
-      options: parsed.options
-    };
-  }
-  if (args.projectRoot === void 0 || !import_node_path2.default.isAbsolute(args.projectRoot)) {
-    return null;
-  }
-  return {
-    containingFile: import_node_path2.default.join(args.projectRoot, "index.ts"),
-    options: DEFAULT_RESOLUTION
-  };
-}
-function unresolvedGatesFor(gates, args) {
-  if (gates.length === 0) {
-    return [];
-  }
-  const context = resolutionContext(args);
-  if (context === null) {
-    return [];
-  }
-  const unresolved = [];
-  for (const gate of gates) {
-    const resolved = import_ts_morph17.ts.resolveModuleName(
-      gate,
-      context.containingFile,
-      context.options,
-      import_ts_morph17.ts.sys
-    );
-    if (resolved.resolvedModule === void 0) {
-      unresolved.push(gate);
-    }
-  }
-  return unresolved;
-}
-function helpersWithNoCall(patterns, matched, projectRoot) {
-  const missing = [];
-  for (const pattern of patterns) {
-    if (pattern.match.type !== "registrationTemplate" || matched.has(pattern.match.helperName)) {
-      continue;
-    }
-    const from = pattern.match.importModule;
-    missing.push(
-      from === void 0 ? pattern.match.helperName : `${pattern.match.helperName} from ${shortModule(from, projectRoot)}`
-    );
-  }
-  return missing;
-}
-function shortModule(module2, projectRoot) {
-  if (projectRoot === void 0 || !import_node_path2.default.isAbsolute(module2)) {
-    return module2;
-  }
-  return import_node_path2.default.relative(projectRoot, module2);
-}
-function buildExtractionReport(args) {
-  const bySummary = (0, import_extractor3.summaryCountsByPack)(args.summaries);
-  const packFunnels = args.packs.map((pack) => {
-    const gates = packIsUngated(pack) ? [] : collectPackGates(pack);
-    const tally = args.tallies.get(pack.name) ?? (0, import_extractor3.emptyTally)();
-    const counted = bySummary.get(pack.name) ?? {
-      bound: 0,
-      providers: 0,
-      withBehavior: 0
-    };
-    return {
-      pack: pack.name,
-      version: pack.version ?? null,
-      discovers: pack.discovery.length > 0 || pack.discoverUnits !== void 0,
-      recognizes: (pack.invocationRecognizers?.length ?? 0) > 0 || (pack.accessRecognizers?.length ?? 0) > 0,
-      gates,
-      unresolvedGates: unresolvedGatesFor(gates, {
-        tsConfigFilePath: args.tsConfigFilePath,
-        projectRoot: args.projectRoot
-      }),
-      candidateFiles: tally.candidateFiles,
-      unitsDiscovered: tally.unitsDiscovered,
-      unitsInGatedFiles: tally.unitsInGatedFiles,
-      effectsRecognized: tally.effectsRecognized,
-      unitsClaimed: tally.unitsClaimed,
-      summariesProduced: tally.summariesProduced,
-      failures: tally.failures,
-      helpersUnmatched: helpersWithNoCall(
-        [...pack.discovery, ...args.contributedPatterns?.(pack.name) ?? []],
-        tally.helpersMatched,
-        args.projectRoot
-      ),
-      summariesBound: counted.bound,
-      providerSummaries: counted.providers,
-      summariesWithBehavior: counted.withBehavior,
-      declarations: pack.declarations ?? null
-    };
-  });
-  return {
-    filesInProject: args.filesInProject,
-    filesWalked: args.filesWalked,
-    packs: packFunnels,
-    summaries: args.summaries.length,
-    filesWithUnreadableExports: [...args.filesWithUnreadableExports ?? []],
-    reassignedNamesUnstated: args.reassignedNamesUnstated ?? 0,
-    emptyStage: args.summaries.length === 0 ? firstEmptyStage(packFunnels, args) : null
-  };
-}
-function firstEmptyStage(packs, args) {
-  if (args.filesInProject === 0) {
-    return "tsconfig";
-  }
-  const gateFailed = packs.some(
-    (p) => p.unresolvedGates.length > 0 && p.candidateFiles > 0
-  );
-  if (gateFailed) {
-    return "gateResolution";
-  }
-  if (args.filesWalked === 0 || packs.every((p) => p.candidateFiles === 0)) {
-    return "candidateFiles";
-  }
-  if (packs.every((p) => p.unitsDiscovered === 0)) {
-    return "discovery";
-  }
-  return "assembly";
-}
-
-// src/discovery/importScan.ts
 function specifierMatches(specifier, moduleName, subpaths) {
   if (specifier === moduleName) {
     return true;
@@ -4661,8 +4494,8 @@ function resolvedModuleFile(project, importModule, resolution) {
 }
 function projectFileNamedBy(project, specifier) {
   const files = project.getSourceFiles().filter((sf) => !sf.isDeclarationFile());
-  const root = commonDirectoryOf(files.map((sf) => sf.getFilePath())) ?? "/";
-  const target = withoutSourceExtension(import_node_path3.default.resolve(root, specifier));
+  const root = (0, import_extractor3.commonDirectoryOf)(files.map((sf) => sf.getFilePath())) ?? "/";
+  const target = withoutSourceExtension(import_node_path2.default.resolve(root, specifier));
   for (const candidate of files) {
     if (withoutSourceExtension(candidate.getFilePath()) === target) {
       return candidate;
@@ -4710,14 +4543,14 @@ function importedReferenceSpellings(sourceFile, importModule, importName) {
 }
 
 // src/discovery/resolveValue.ts
-var import_ts_morph19 = require("ts-morph");
+var import_ts_morph18 = require("ts-morph");
 var import_values3 = require("@suss/values");
 
 // src/values/evaluator.ts
 var import_values2 = require("@suss/values");
 
 // src/values/lowering.ts
-var import_ts_morph18 = require("ts-morph");
+var import_ts_morph17 = require("ts-morph");
 var ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
   "=",
   "+=",
@@ -4781,11 +4614,11 @@ function typescriptLowering(options) {
     },
     callable: (node) => {
       const call = peelValue(node);
-      if (resolution === void 0 || !import_ts_morph18.Node.isCallExpression(call) && !import_ts_morph18.Node.isNewExpression(call)) {
+      if (resolution === void 0 || !import_ts_morph17.Node.isCallExpression(call) && !import_ts_morph17.Node.isNewExpression(call)) {
         return null;
       }
       const target = resolution.resolveCallable(call.getExpression());
-      return target !== null && import_ts_morph18.Node.isFunctionLikeDeclaration(target) ? target : null;
+      return target !== null && import_ts_morph17.Node.isFunctionLikeDeclaration(target) ? target : null;
     },
     mutatedInNestedFunction: (root, name) => {
       let mutated = mutatedByRoot.get(root);
@@ -4801,34 +4634,34 @@ function typescriptLowering(options) {
   };
 }
 function placeholderName(expr) {
-  if (import_ts_morph18.Node.isIdentifier(expr)) {
+  if (import_ts_morph17.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph18.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph17.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return "param";
 }
 function expressionOf(node, originOf) {
-  if (import_ts_morph18.Node.isStringLiteral(node) || import_ts_morph18.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph17.Node.isStringLiteral(node) || import_ts_morph17.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { kind: "literal", value: node.getLiteralValue() };
   }
-  if (import_ts_morph18.Node.isNumericLiteral(node)) {
+  if (import_ts_morph17.Node.isNumericLiteral(node)) {
     return { kind: "literal", value: node.getLiteralValue() };
   }
-  if (import_ts_morph18.Node.isTrueLiteral(node)) {
+  if (import_ts_morph17.Node.isTrueLiteral(node)) {
     return { kind: "literal", value: true };
   }
-  if (import_ts_morph18.Node.isFalseLiteral(node)) {
+  if (import_ts_morph17.Node.isFalseLiteral(node)) {
     return { kind: "literal", value: false };
   }
-  if (import_ts_morph18.Node.isNullLiteral(node)) {
+  if (import_ts_morph17.Node.isNullLiteral(node)) {
     return { kind: "literal", value: null };
   }
-  if (import_ts_morph18.Node.isIdentifier(node)) {
+  if (import_ts_morph17.Node.isIdentifier(node)) {
     return node.getText() === "undefined" ? { kind: "literal", value: void 0 } : { kind: "name", text: node.getText() };
   }
-  if (import_ts_morph18.Node.isTemplateExpression(node)) {
+  if (import_ts_morph17.Node.isTemplateExpression(node)) {
     return {
       kind: "template",
       parts: [
@@ -4840,32 +4673,32 @@ function expressionOf(node, originOf) {
       ]
     };
   }
-  if (import_ts_morph18.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph17.Node.isPropertyAccessExpression(node)) {
     return {
       kind: "member",
       object: node.getExpression(),
       name: node.getName()
     };
   }
-  if (import_ts_morph18.Node.isElementAccessExpression(node)) {
+  if (import_ts_morph17.Node.isElementAccessExpression(node)) {
     const index = node.getArgumentExpression();
     return index === void 0 ? { kind: "opaque" } : { kind: "element", object: node.getExpression(), index };
   }
-  if (import_ts_morph18.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph17.Node.isArrayLiteralExpression(node)) {
     return { kind: "array", items: node.getElements().map(elementOf) };
   }
-  if (import_ts_morph18.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph17.Node.isObjectLiteralExpression(node)) {
     return { kind: "record", fields: node.getProperties().flatMap(fieldOf) };
   }
-  if (import_ts_morph18.Node.isCallExpression(node) || import_ts_morph18.Node.isNewExpression(node)) {
+  if (import_ts_morph17.Node.isCallExpression(node) || import_ts_morph17.Node.isNewExpression(node)) {
     return {
       kind: "call",
       callee: calleeOf(node.getExpression(), originOf),
       args: node.getArguments().map(elementOf),
-      constructs: import_ts_morph18.Node.isNewExpression(node)
+      constructs: import_ts_morph17.Node.isNewExpression(node)
     };
   }
-  if (import_ts_morph18.Node.isBinaryExpression(node)) {
+  if (import_ts_morph17.Node.isBinaryExpression(node)) {
     const operator = node.getOperatorToken().getText();
     return ASSIGNMENT_OPERATORS.has(operator) ? { kind: "opaque" } : {
       kind: "operator",
@@ -4873,11 +4706,11 @@ function expressionOf(node, originOf) {
       operands: [node.getLeft(), node.getRight()]
     };
   }
-  if (import_ts_morph18.Node.isPrefixUnaryExpression(node)) {
+  if (import_ts_morph17.Node.isPrefixUnaryExpression(node)) {
     const operator = node.getOperatorToken();
-    return operator === import_ts_morph18.SyntaxKind.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
+    return operator === import_ts_morph17.SyntaxKind.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
   }
-  if (import_ts_morph18.Node.isConditionalExpression(node)) {
+  if (import_ts_morph17.Node.isConditionalExpression(node)) {
     return {
       kind: "conditional",
       condition: node.getCondition(),
@@ -4885,23 +4718,23 @@ function expressionOf(node, originOf) {
       whenFalse: node.getWhenFalse()
     };
   }
-  if (import_ts_morph18.Node.isArrowFunction(node) || import_ts_morph18.Node.isFunctionExpression(node)) {
+  if (import_ts_morph17.Node.isArrowFunction(node) || import_ts_morph17.Node.isFunctionExpression(node)) {
     return { kind: "function", node };
   }
   return { kind: "opaque" };
 }
 function elementOf(node) {
-  return import_ts_morph18.Node.isSpreadElement(node) ? { kind: "spread", node: node.getExpression() } : { kind: "value", node };
+  return import_ts_morph17.Node.isSpreadElement(node) ? { kind: "spread", node: node.getExpression() } : { kind: "value", node };
 }
 function fieldOf(property) {
-  if (import_ts_morph18.Node.isSpreadAssignment(property)) {
+  if (import_ts_morph17.Node.isSpreadAssignment(property)) {
     return [{ kind: "spread", node: property.getExpression() }];
   }
-  if (import_ts_morph18.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph17.Node.isShorthandPropertyAssignment(property)) {
     const nameNode2 = property.getNameNode();
     return [{ kind: "field", name: nameNode2.getText(), value: nameNode2 }];
   }
-  if (!import_ts_morph18.Node.isPropertyAssignment(property)) {
+  if (!import_ts_morph17.Node.isPropertyAssignment(property)) {
     return [];
   }
   const value = property.getInitializer();
@@ -4909,22 +4742,22 @@ function fieldOf(property) {
     return [];
   }
   const nameNode = property.getNameNode();
-  if (import_ts_morph18.Node.isComputedPropertyName(nameNode)) {
+  if (import_ts_morph17.Node.isComputedPropertyName(nameNode)) {
     return [{ kind: "computed", name: nameNode.getExpression(), value }];
   }
-  const name = import_ts_morph18.Node.isStringLiteral(nameNode) || import_ts_morph18.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+  const name = import_ts_morph17.Node.isStringLiteral(nameNode) || import_ts_morph17.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
   return [{ kind: "field", name, value }];
 }
 function calleeOf(expression, originOf) {
   const callee = peelValue(expression);
-  if (import_ts_morph18.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph17.Node.isPropertyAccessExpression(callee)) {
     return {
       receiver: callee.getExpression(),
       name: callee.getName(),
       origin: () => originOf(callee)
     };
   }
-  if (import_ts_morph18.Node.isIdentifier(callee)) {
+  if (import_ts_morph17.Node.isIdentifier(callee)) {
     return {
       receiver: null,
       name: callee.getText(),
@@ -4936,17 +4769,17 @@ function calleeOf(expression, originOf) {
 function memberChainOf(node) {
   const names = [];
   let current2 = peelValue(node);
-  while (import_ts_morph18.Node.isPropertyAccessExpression(current2)) {
+  while (import_ts_morph17.Node.isPropertyAccessExpression(current2)) {
     names.unshift(current2.getName());
     current2 = peelValue(current2.getExpression());
   }
-  if (!import_ts_morph18.Node.isIdentifier(current2)) {
+  if (!import_ts_morph17.Node.isIdentifier(current2)) {
     return null;
   }
   return { root: current2, names: [current2.getText(), ...names] };
 }
 function statementOf2(node) {
-  if (import_ts_morph18.Node.isVariableStatement(node)) {
+  if (import_ts_morph17.Node.isVariableStatement(node)) {
     return {
       kind: "declare",
       bindings: node.getDeclarationList().getDeclarations().flatMap(
@@ -4957,9 +4790,9 @@ function statementOf2(node) {
       )
     };
   }
-  if (import_ts_morph18.Node.isExpressionStatement(node)) {
+  if (import_ts_morph17.Node.isExpressionStatement(node)) {
     const expression = peelValue(node.getExpression());
-    if (import_ts_morph18.Node.isBinaryExpression(expression)) {
+    if (import_ts_morph17.Node.isBinaryExpression(expression)) {
       const operator = expression.getOperatorToken().getText();
       if (ASSIGNMENT_OPERATORS.has(operator)) {
         return {
@@ -4972,7 +4805,7 @@ function statementOf2(node) {
     }
     return { kind: "expression", value: node.getExpression() };
   }
-  if (import_ts_morph18.Node.isIfStatement(node)) {
+  if (import_ts_morph17.Node.isIfStatement(node)) {
     const otherwise = node.getElseStatement();
     return {
       kind: "branch",
@@ -4983,23 +4816,23 @@ function statementOf2(node) {
       ]
     };
   }
-  if (import_ts_morph18.Node.isSwitchStatement(node)) {
+  if (import_ts_morph17.Node.isSwitchStatement(node)) {
     return {
       kind: "branch",
       condition: null,
       arms: node.getClauses().map((clause) => clause.getStatements())
     };
   }
-  if (import_ts_morph18.Node.isIterationStatement(node)) {
+  if (import_ts_morph17.Node.isIterationStatement(node)) {
     return { kind: "loop", body: armOf(node.getStatement()) };
   }
-  if (import_ts_morph18.Node.isReturnStatement(node)) {
+  if (import_ts_morph17.Node.isReturnStatement(node)) {
     return { kind: "return", value: node.getExpression() ?? null };
   }
-  if (import_ts_morph18.Node.isBlock(node)) {
+  if (import_ts_morph17.Node.isBlock(node)) {
     return { kind: "block", body: node.getStatements() };
   }
-  if (import_ts_morph18.Node.isTryStatement(node)) {
+  if (import_ts_morph17.Node.isTryStatement(node)) {
     return {
       kind: "block",
       body: [
@@ -5011,31 +4844,31 @@ function statementOf2(node) {
   return { kind: "opaque" };
 }
 function armOf(statement) {
-  return import_ts_morph18.Node.isBlock(statement) ? statement.getStatements() : [statement];
+  return import_ts_morph17.Node.isBlock(statement) ? statement.getStatements() : [statement];
 }
 function declarationsOf2(nameNode, value) {
-  if (import_ts_morph18.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph17.Node.isIdentifier(nameNode)) {
     return [{ name: nameNode.getText(), value }];
   }
-  if (import_ts_morph18.Node.isObjectBindingPattern(nameNode) || import_ts_morph18.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph17.Node.isObjectBindingPattern(nameNode) || import_ts_morph17.Node.isArrayBindingPattern(nameNode)) {
     return nameNode.getElements().flatMap(
-      (element) => import_ts_morph18.Node.isBindingElement(element) ? declarationsOf2(element.getNameNode(), null) : []
+      (element) => import_ts_morph17.Node.isBindingElement(element) ? declarationsOf2(element.getNameNode(), null) : []
     );
   }
   return [];
 }
 function isRoot(node) {
-  return import_ts_morph18.Node.isSourceFile(node) || import_ts_morph18.Node.isFunctionLikeDeclaration(node);
+  return import_ts_morph17.Node.isSourceFile(node) || import_ts_morph17.Node.isFunctionLikeDeclaration(node);
 }
 function isStandaloneBlock(node) {
   const parent = node.getParent();
-  return parent !== void 0 && (import_ts_morph18.Node.isBlock(parent) || import_ts_morph18.Node.isSourceFile(parent) || import_ts_morph18.Node.isModuleBlock(parent) || import_ts_morph18.Node.isCaseClause(parent) || import_ts_morph18.Node.isDefaultClause(parent));
+  return parent !== void 0 && (import_ts_morph17.Node.isBlock(parent) || import_ts_morph17.Node.isSourceFile(parent) || import_ts_morph17.Node.isModuleBlock(parent) || import_ts_morph17.Node.isCaseClause(parent) || import_ts_morph17.Node.isDefaultClause(parent));
 }
 function isPathStatement(node) {
-  if (import_ts_morph18.Node.isBlock(node)) {
+  if (import_ts_morph17.Node.isBlock(node)) {
     return isStandaloneBlock(node);
   }
-  return import_ts_morph18.Node.isStatement(node) && !import_ts_morph18.Node.isFunctionDeclaration(node);
+  return import_ts_morph17.Node.isStatement(node) && !import_ts_morph17.Node.isFunctionDeclaration(node);
 }
 function siteOf(node) {
   const path15 = [];
@@ -5055,26 +4888,26 @@ function siteOf(node) {
   }
 }
 function functionOf(node) {
-  if (import_ts_morph18.Node.isSourceFile(node)) {
+  if (import_ts_morph17.Node.isSourceFile(node)) {
     return { parameters: [], body: node.getStatements() };
   }
-  if (!import_ts_morph18.Node.isFunctionLikeDeclaration(node)) {
+  if (!import_ts_morph17.Node.isFunctionLikeDeclaration(node)) {
     return null;
   }
   const parameters = node.getParameters().flatMap((parameter) => {
     const nameNode = parameter.getNameNode();
-    return import_ts_morph18.Node.isIdentifier(nameNode) ? [
+    return import_ts_morph17.Node.isIdentifier(nameNode) ? [
       {
         name: nameNode.getText(),
         default: parameter.getInitializer() ?? null
       }
     ] : [];
   });
-  const body = import_ts_morph18.Node.isBodied(node) ? node.getBody() : import_ts_morph18.Node.isBodyable(node) ? node.getBody() : void 0;
+  const body = import_ts_morph17.Node.isBodied(node) ? node.getBody() : import_ts_morph17.Node.isBodyable(node) ? node.getBody() : void 0;
   if (body === void 0) {
     return { parameters, body: [] };
   }
-  return import_ts_morph18.Node.isBlock(body) ? { parameters, body: body.getStatements() } : { parameters, body: { expression: body } };
+  return import_ts_morph17.Node.isBlock(body) ? { parameters, body: body.getStatements() } : { parameters, body: { expression: body } };
 }
 function namesMutatedInNestedFunctions(root) {
   const mutated = /* @__PURE__ */ new Set();
@@ -5087,21 +4920,21 @@ function namesMutatedInNestedFunctions(root) {
   return mutated;
 }
 function writtenNameOf(node) {
-  if (import_ts_morph18.Node.isBinaryExpression(node)) {
+  if (import_ts_morph17.Node.isBinaryExpression(node)) {
     const target = peelValue(node.getLeft());
-    return ASSIGNMENT_OPERATORS.has(node.getOperatorToken().getText()) && import_ts_morph18.Node.isIdentifier(target) ? target.getText() : null;
+    return ASSIGNMENT_OPERATORS.has(node.getOperatorToken().getText()) && import_ts_morph17.Node.isIdentifier(target) ? target.getText() : null;
   }
-  if (import_ts_morph18.Node.isPostfixUnaryExpression(node) || import_ts_morph18.Node.isPrefixUnaryExpression(node)) {
+  if (import_ts_morph17.Node.isPostfixUnaryExpression(node) || import_ts_morph17.Node.isPrefixUnaryExpression(node)) {
     const operand2 = peelValue(node.getOperand());
-    return import_ts_morph18.Node.isIdentifier(operand2) ? operand2.getText() : null;
+    return import_ts_morph17.Node.isIdentifier(operand2) ? operand2.getText() : null;
   }
-  if (import_ts_morph18.Node.isCallExpression(node)) {
+  if (import_ts_morph17.Node.isCallExpression(node)) {
     const callee = peelValue(node.getExpression());
-    if (!import_ts_morph18.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph17.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     const receiver = peelValue(callee.getExpression());
-    return MUTATING_METHODS.has(callee.getName()) && import_ts_morph18.Node.isIdentifier(receiver) ? receiver.getText() : null;
+    return MUTATING_METHODS.has(callee.getName()) && import_ts_morph17.Node.isIdentifier(receiver) ? receiver.getText() : null;
   }
   return null;
 }
@@ -5116,18 +4949,18 @@ function freeNamesOf(fn) {
   const declared = /* @__PURE__ */ new Set();
   const read2 = /* @__PURE__ */ new Set();
   fn.forEachDescendant((descendant) => {
-    if (!import_ts_morph18.Node.isIdentifier(descendant)) {
+    if (!import_ts_morph17.Node.isIdentifier(descendant)) {
       return;
     }
     const parent = descendant.getParent();
-    if (import_ts_morph18.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === descendant) {
+    if (import_ts_morph17.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === descendant) {
       return;
     }
-    if (import_ts_morph18.Node.isVariableDeclaration(parent) || import_ts_morph18.Node.isParameterDeclaration(parent) || import_ts_morph18.Node.isBindingElement(parent) || import_ts_morph18.Node.isFunctionDeclaration(parent)) {
+    if (import_ts_morph17.Node.isVariableDeclaration(parent) || import_ts_morph17.Node.isParameterDeclaration(parent) || import_ts_morph17.Node.isBindingElement(parent) || import_ts_morph17.Node.isFunctionDeclaration(parent)) {
       declared.add(descendant.getText());
       return;
     }
-    if (import_ts_morph18.Node.isPropertyAssignment(parent) && parent.getNameNode() === descendant) {
+    if (import_ts_morph17.Node.isPropertyAssignment(parent) && parent.getNameNode() === descendant) {
       return;
     }
     read2.add(descendant.getText());
@@ -5291,13 +5124,13 @@ function evaluatedValue(node, resolution) {
 
 // src/discovery/resolveValue.ts
 function couldNameAValue(value) {
-  return import_ts_morph19.Node.isIdentifier(value) || import_ts_morph19.Node.isPropertyAccessExpression(value) || import_ts_morph19.Node.isElementAccessExpression(value) || import_ts_morph19.Node.isCallExpression(value);
+  return import_ts_morph18.Node.isIdentifier(value) || import_ts_morph18.Node.isPropertyAccessExpression(value) || import_ts_morph18.Node.isElementAccessExpression(value) || import_ts_morph18.Node.isCallExpression(value);
 }
 function propertyValueOf(property) {
-  if (import_ts_morph19.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph18.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph19.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph18.Node.isShorthandPropertyAssignment(property)) {
     return property.getNameNode();
   }
   return null;
@@ -5315,20 +5148,20 @@ function functionValueOf(value, resolution) {
   if (resolved !== null) {
     return toFunctionRoot(resolved);
   }
-  if (!import_ts_morph19.Node.isCallExpression(written)) {
+  if (!import_ts_morph18.Node.isCallExpression(written)) {
     return null;
   }
   const returned = resolution.resolveReturnedCallable(written);
   return returned === null ? null : toFunctionRoot(returned);
 }
 function propertyNameOf(property) {
-  if (import_ts_morph19.Node.isPropertyAssignment(property) || import_ts_morph19.Node.isShorthandPropertyAssignment(property) || import_ts_morph19.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph18.Node.isPropertyAssignment(property) || import_ts_morph18.Node.isShorthandPropertyAssignment(property) || import_ts_morph18.Node.isMethodDeclaration(property)) {
     return property.getName();
   }
   return null;
 }
 function propertyFunctionOf(property, resolution) {
-  if (import_ts_morph19.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph18.Node.isMethodDeclaration(property)) {
     return property;
   }
   const held = propertyValueOf(property);
@@ -5338,7 +5171,7 @@ function objectLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph19.Node.isObjectLiteralExpression(node)
+    (node) => import_ts_morph18.Node.isObjectLiteralExpression(node)
   );
 }
 function propertiesOf(object, resolution) {
@@ -5350,7 +5183,7 @@ function propertiesReached(object, resolution, seen) {
   }
   seen.add(object);
   return object.getProperties().flatMap((property) => {
-    if (!import_ts_morph19.Node.isSpreadAssignment(property)) {
+    if (!import_ts_morph18.Node.isSpreadAssignment(property)) {
       return [property];
     }
     const spread = objectLiteralOf(property.getExpression(), resolution);
@@ -5359,17 +5192,17 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (import_ts_morph19.Node.isNewExpression(written)) {
+  if (import_ts_morph18.Node.isNewExpression(written)) {
     return written;
   }
-  if (import_ts_morph19.Node.isCallExpression(written)) {
+  if (import_ts_morph18.Node.isCallExpression(written)) {
     return writtenThroughCall(written, resolution);
   }
   if (resolution === void 0 || !couldNameAValue(written)) {
     return null;
   }
   const resolved = resolution.resolveWrittenValue(written);
-  return resolved !== null && import_ts_morph19.Node.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
+  return resolved !== null && import_ts_morph18.Node.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
 }
 function writtenThroughCall(call, resolution) {
   if (resolution !== void 0 && resolution.resolveCallable(call.getExpression()) !== null) {
@@ -5395,7 +5228,7 @@ function arrayLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph19.Node.isArrayLiteralExpression(node)
+    (node) => import_ts_morph18.Node.isArrayLiteralExpression(node)
   );
 }
 function literalValueOf(value, resolution, isWanted) {
@@ -5418,26 +5251,26 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   if (!isGlobal) {
     for (const varDecl of sourceFile.getVariableDeclarations()) {
       const init = varDecl.getInitializer();
-      if (init !== void 0 && (import_ts_morph20.Node.isCallExpression(init) || import_ts_morph20.Node.isNewExpression(init)) && isCreationCall(init, match, resolution)) {
+      if (init !== void 0 && (import_ts_morph19.Node.isCallExpression(init) || import_ts_morph19.Node.isNewExpression(init)) && isCreationCall(init, match, resolution)) {
         clientVarNames.add(varDecl.getName());
       }
     }
   }
   const methodFilter = match.methodFilter !== void 0 ? new Set(match.methodFilter) : null;
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph20.Node.isCallExpression(node)) {
+    if (!import_ts_morph19.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
     let methodName = null;
     let matched = false;
-    if (isGlobal && import_ts_morph20.Node.isIdentifier(callee)) {
+    if (isGlobal && import_ts_morph19.Node.isIdentifier(callee)) {
       if (callee.getText() === match.importName) {
         matched = true;
       }
-    } else if (import_ts_morph20.Node.isPropertyAccessExpression(callee)) {
+    } else if (import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph20.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
+      if (import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -5471,16 +5304,16 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
   );
   const constructedHere = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph20.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph19.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && (import_ts_morph20.Node.isCallExpression(init) || import_ts_morph20.Node.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+      if (init !== void 0 && (import_ts_morph19.Node.isCallExpression(init) || import_ts_morph19.Node.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
         constructedHere.add(node.getName());
       }
       return;
     }
-    if (import_ts_morph20.Node.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+    if (import_ts_morph19.Node.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
       const written = node.getNameNode();
-      if (import_ts_morph20.Node.isIdentifier(written)) {
+      if (import_ts_morph19.Node.isIdentifier(written)) {
         constructedHere.add(written.getText());
       }
     }
@@ -5491,10 +5324,10 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
     importName: match.importName,
     ...match.factoryMethods === void 0 ? {} : { factoryMethods: match.factoryMethods }
   };
-  return (subject) => isClientImport(subject, match, resolution, true) || import_ts_morph20.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
+  return (subject) => isClientImport(subject, match, resolution, true) || import_ts_morph19.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
 }
 function typedAsClient(typeNode, localName) {
-  if (typeNode === void 0 || !import_ts_morph20.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph19.Node.isTypeReference(typeNode)) {
     return false;
   }
   return typeNode.getTypeName().getText() === localName;
@@ -5504,27 +5337,27 @@ function resolvesToKnownInstance(subject, match, resolution) {
     return false;
   }
   const written = writtenNodeOf(subject, resolution);
-  if (written === null || !import_ts_morph20.Node.isCallExpression(written) && !import_ts_morph20.Node.isNewExpression(written)) {
+  if (written === null || !import_ts_morph19.Node.isCallExpression(written) && !import_ts_morph19.Node.isNewExpression(written)) {
     return false;
   }
   return isCreationCall(written, match, resolution);
 }
 function isCreationCall(call, match, resolution) {
   const callee = call.getExpression();
-  if (import_ts_morph20.Node.isIdentifier(callee)) {
+  if (import_ts_morph19.Node.isIdentifier(callee)) {
     return isClientImport(callee, match, resolution, false);
   }
-  if (!import_ts_morph20.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
     return false;
   }
   const base = callee.getExpression();
-  return import_ts_morph20.Node.isIdentifier(base) && (match.factoryMethods?.includes(callee.getName()) ?? false) && isClientImport(base, match, resolution, false);
+  return import_ts_morph19.Node.isIdentifier(base) && (match.factoryMethods?.includes(callee.getName()) ?? false) && isClientImport(base, match, resolution, false);
 }
 function isPathShaped(specifier) {
   return specifier.startsWith(".") || specifier.startsWith("/");
 }
 function isClientImport(subject, match, resolution, strictDefaultName) {
-  if (!import_ts_morph20.Node.isIdentifier(subject)) {
+  if (!import_ts_morph19.Node.isIdentifier(subject)) {
     return false;
   }
   if (resolution === void 0) {
@@ -5572,27 +5405,27 @@ function resolvedImportLocalName(sourceFile, importModule, importName, strictDef
   return null;
 }
 function clientUnitName(enclosingFunc, methodName) {
-  if (import_ts_morph20.Node.isFunctionDeclaration(enclosingFunc)) {
+  if (import_ts_morph19.Node.isFunctionDeclaration(enclosingFunc)) {
     return enclosingFunc.getName() ?? methodName ?? "anonymous";
   }
-  if (import_ts_morph20.Node.isMethodDeclaration(enclosingFunc)) {
+  if (import_ts_morph19.Node.isMethodDeclaration(enclosingFunc)) {
     return enclosingFunc.getName();
   }
   const parent = enclosingFunc.getParent();
-  if (parent !== void 0 && import_ts_morph20.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph19.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
-  if (parent !== void 0 && import_ts_morph20.Node.isPropertyAssignment(parent)) {
+  if (parent !== void 0 && import_ts_morph19.Node.isPropertyAssignment(parent)) {
     return parent.getName();
   }
   return methodName ?? "anonymous";
 }
 
 // src/discovery/decoratedMethod.ts
-var import_ts_morph23 = require("ts-morph");
+var import_ts_morph22 = require("ts-morph");
 
 // src/discovery/decoratedMembers.ts
-var import_ts_morph21 = require("ts-morph");
+var import_ts_morph20 = require("ts-morph");
 function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
   const localToCanonical = /* @__PURE__ */ new Map();
   for (const importDecl of sourceFile.getImportDeclarations()) {
@@ -5612,7 +5445,7 @@ function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
 function decoratedCallablesOf(cls, decoratorNames) {
   const callables = [];
   for (const member of cls.getMembers()) {
-    if (!import_ts_morph21.Node.isMethodDeclaration(member) && !import_ts_morph21.Node.isPropertyDeclaration(member)) {
+    if (!import_ts_morph20.Node.isMethodDeclaration(member) && !import_ts_morph20.Node.isPropertyDeclaration(member)) {
       continue;
     }
     const func = callableOf(member);
@@ -5636,7 +5469,7 @@ function decoratedCallablesOf(cls, decoratorNames) {
   return callables;
 }
 function callableOf(member) {
-  if (import_ts_morph21.Node.isMethodDeclaration(member)) {
+  if (import_ts_morph20.Node.isMethodDeclaration(member)) {
     return toFunctionRoot(member);
   }
   const held = member.getInitializer();
@@ -5644,7 +5477,7 @@ function callableOf(member) {
 }
 
 // src/discovery/decoratorComposition.ts
-var import_ts_morph22 = require("ts-morph");
+var import_ts_morph21 = require("ts-morph");
 function classDecoratorStandingFor(cls, names, modules, resolution) {
   for (const candidate of names) {
     const decorator = cls.getDecorator(candidate);
@@ -5682,7 +5515,7 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   if (wrapper === null) {
     return atClass;
   }
-  for (const call of wrapper.getDescendantsOfKind(import_ts_morph22.SyntaxKind.CallExpression)) {
+  for (const call of wrapper.getDescendantsOfKind(import_ts_morph21.SyntaxKind.CallExpression)) {
     const names = resolution.importedNamesOf(call.getExpression(), modules);
     if (!names.includes(standsFor)) {
       continue;
@@ -5693,10 +5526,10 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   return atClass;
 }
 function statesAValue(arg, wrapper) {
-  const identifiers = import_ts_morph22.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph22.SyntaxKind.Identifier);
+  const identifiers = import_ts_morph21.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph21.SyntaxKind.Identifier);
   return !identifiers.some(
     (identifier) => identifier.getSymbol()?.getDeclarations().some(
-      (declaration) => import_ts_morph22.Node.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
+      (declaration) => import_ts_morph21.Node.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
     )
   );
 }
@@ -5716,39 +5549,39 @@ function resolverTypeName(args) {
   return args.typeMap[args.decoratorName] ?? args.classTypeName ?? null;
 }
 function resolveResolverClassTypeName(decoratorArg) {
-  if (import_ts_morph23.Node.isArrowFunction(decoratorArg)) {
+  if (import_ts_morph22.Node.isArrowFunction(decoratorArg)) {
     const body = decoratorArg.getBody();
-    if (import_ts_morph23.Node.isIdentifier(body)) {
+    if (import_ts_morph22.Node.isIdentifier(body)) {
       return body.getText();
     }
     return null;
   }
-  if (import_ts_morph23.Node.isStringLiteral(decoratorArg)) {
+  if (import_ts_morph22.Node.isStringLiteral(decoratorArg)) {
     return decoratorArg.getLiteralValue();
   }
-  if (import_ts_morph23.Node.isIdentifier(decoratorArg)) {
+  if (import_ts_morph22.Node.isIdentifier(decoratorArg)) {
     return decoratorArg.getText();
   }
   return null;
 }
 function resolveOperationNameOverride(decorator) {
-  if (!import_ts_morph23.Node.isDecorator(decorator)) {
+  if (!import_ts_morph22.Node.isDecorator(decorator)) {
     return null;
   }
   const args = decorator.getArguments();
   for (const arg of args) {
-    if (!import_ts_morph23.Node.isObjectLiteralExpression(arg)) {
+    if (!import_ts_morph22.Node.isObjectLiteralExpression(arg)) {
       continue;
     }
     const prop = arg.getProperty("name");
-    if (prop === void 0 || !import_ts_morph23.Node.isPropertyAssignment(prop)) {
+    if (prop === void 0 || !import_ts_morph22.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const init = prop.getInitializer();
     if (init === void 0) {
       continue;
     }
-    if (import_ts_morph23.Node.isStringLiteral(init) || import_ts_morph23.Node.isNoSubstitutionTemplateLiteral(init)) {
+    if (import_ts_morph22.Node.isStringLiteral(init) || import_ts_morph22.Node.isNoSubstitutionTemplateLiteral(init)) {
       return init.getLiteralValue();
     }
   }
@@ -5801,9 +5634,9 @@ function discoverDecoratedMethods(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/decoratedRoute.ts
-var import_ts_morph24 = require("ts-morph");
+var import_ts_morph23 = require("ts-morph");
 function resolveRoutePathArg(decorator, resolution) {
-  if (!import_ts_morph24.Node.isDecorator(decorator)) {
+  if (!import_ts_morph23.Node.isDecorator(decorator)) {
     return "";
   }
   return routePathOf(decorator.getArguments(), resolution);
@@ -5831,7 +5664,7 @@ function declaredChannelOf(source, decorator, resolution) {
   if (source.from === "unstated") {
     return null;
   }
-  if (!import_ts_morph24.Node.isDecorator(decorator)) {
+  if (!import_ts_morph23.Node.isDecorator(decorator)) {
     return null;
   }
   const arg = decorator.getArguments()[source.position];
@@ -5842,7 +5675,7 @@ function declaredChannelOf(source, decorator, resolution) {
   return text === null || text === "" ? null : text;
 }
 function literalStringOf(node, resolution) {
-  if (import_ts_morph24.Node.isStringLiteral(node) || import_ts_morph24.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph23.Node.isStringLiteral(node) || import_ts_morph23.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   const written = resolution?.resolveWrittenValue(node) ?? null;
@@ -5912,31 +5745,31 @@ function discoverDecoratedRoutes(sourceFile, match, kind, resolution, binding) {
 var import_picomatch = __toESM(require("picomatch"), 1);
 
 // src/discovery/namedExport.ts
-var import_ts_morph25 = require("ts-morph");
+var import_ts_morph24 = require("ts-morph");
 function nameWrittenAt(expression) {
-  if (import_ts_morph25.Node.isIdentifier(expression)) {
+  if (import_ts_morph24.Node.isIdentifier(expression)) {
     return expression.getText();
   }
-  if (import_ts_morph25.Node.isPropertyAccessExpression(expression)) {
+  if (import_ts_morph24.Node.isPropertyAccessExpression(expression)) {
     return expression.getName();
   }
   return null;
 }
 function resolveDefaultExportName(decl, fn) {
-  if (import_ts_morph25.Node.isFunctionDeclaration(fn) || import_ts_morph25.Node.isFunctionExpression(fn)) {
+  if (import_ts_morph24.Node.isFunctionDeclaration(fn) || import_ts_morph24.Node.isFunctionExpression(fn)) {
     const n = fn.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph25.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph24.Node.isVariableDeclaration(decl)) {
     const name = decl.getName();
     if (name.length > 0) {
       return name;
     }
   }
   const binding = fn.getParent();
-  if (binding !== void 0 && import_ts_morph25.Node.isVariableDeclaration(binding)) {
+  if (binding !== void 0 && import_ts_morph24.Node.isVariableDeclaration(binding)) {
     const name = binding.getName();
     if (name.length > 0) {
       return name;
@@ -5991,7 +5824,7 @@ function discoverNamedExports(sourceFile, match, kind, resolution) {
       }
       continue;
     }
-    if (import_ts_morph25.Node.isArrowFunction(init) || import_ts_morph25.Node.isFunctionExpression(init)) {
+    if (import_ts_morph24.Node.isArrowFunction(init) || import_ts_morph24.Node.isFunctionExpression(init)) {
       results.push({
         func: init,
         kind,
@@ -6100,13 +5933,13 @@ function discoverFileConventions(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlHookCall.ts
-var import_ts_morph28 = require("ts-morph");
+var import_ts_morph27 = require("ts-morph");
 
 // src/discovery/graphqlShared.ts
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_graphql = require("graphql");
-var import_ts_morph26 = require("ts-morph");
+var import_ts_morph25 = require("ts-morph");
 var DOCUMENT_TAGS = /* @__PURE__ */ new Set(["gql", "graphql"]);
 var UNQUALIFIED_DOCUMENT_TAG = "gql";
 function parseGraphqlOperation(source) {
@@ -6172,10 +6005,10 @@ function startAssembly(resolution) {
   };
 }
 function assembledTemplateText(template, assembly) {
-  if (import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(template)) {
+  if (import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(template)) {
     return innerTemplateText(template);
   }
-  if (!import_ts_morph26.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph25.Node.isTemplateExpression(template)) {
     return null;
   }
   let text = template.getHead().getLiteralText();
@@ -6311,7 +6144,7 @@ function collectDanglingSpreads(selectionSet, defined, dangling) {
   }
 }
 function documentTextFromExpression(node, assembly) {
-  if (import_ts_morph26.Node.isTaggedTemplateExpression(node)) {
+  if (import_ts_morph25.Node.isTaggedTemplateExpression(node)) {
     if (!isDocumentTag(node.getTag())) {
       return null;
     }
@@ -6321,7 +6154,7 @@ function documentTextFromExpression(node, assembly) {
     assembly.seen.add(node);
     return assembledTemplateText(node.getTemplate(), assembly);
   }
-  if (!import_ts_morph26.Node.isCallExpression(node)) {
+  if (!import_ts_morph25.Node.isCallExpression(node)) {
     return null;
   }
   if (!isDocumentTag(node.getExpression())) {
@@ -6332,7 +6165,7 @@ function documentTextFromExpression(node, assembly) {
     return null;
   }
   const template = stripDocumentNodeCasts(first);
-  if (!import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph26.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph25.Node.isTemplateExpression(template)) {
     return null;
   }
   if (assembly.seen.has(node)) {
@@ -6342,7 +6175,7 @@ function documentTextFromExpression(node, assembly) {
   return assembledTemplateText(template, assembly);
 }
 function isDocumentTag(tag) {
-  if (!import_ts_morph26.Node.isIdentifier(tag)) {
+  if (!import_ts_morph25.Node.isIdentifier(tag)) {
     return false;
   }
   if (tag.getText() === UNQUALIFIED_DOCUMENT_TAG) {
@@ -6353,14 +6186,14 @@ function isDocumentTag(tag) {
     return false;
   }
   for (const declaration of symbol.getDeclarations()) {
-    if (import_ts_morph26.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
+    if (import_ts_morph25.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
       return true;
     }
   }
   return false;
 }
 function resolveThroughFacts(arg, assembly) {
-  if (assembly.resolution === void 0 || !import_ts_morph26.Node.isIdentifier(arg)) {
+  if (assembly.resolution === void 0 || !import_ts_morph25.Node.isIdentifier(arg)) {
     return null;
   }
   const written = assembly.resolution.resolveWrittenValue(arg);
@@ -6409,7 +6242,7 @@ function singleLine(text) {
   return collapsed.length > 80 ? `${collapsed.slice(0, 79)}\u2026` : collapsed;
 }
 function importedVariableInitializers(identifier) {
-  if (!import_ts_morph26.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph25.Node.isIdentifier(identifier)) {
     return [];
   }
   const symbol = identifier.getSymbol();
@@ -6419,7 +6252,7 @@ function importedVariableInitializers(identifier) {
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   const inits = [];
   for (const decl of resolved.getDeclarations()) {
-    if (import_ts_morph26.Node.isVariableDeclaration(decl)) {
+    if (import_ts_morph25.Node.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
       if (init !== void 0) {
         inits.push(init);
@@ -6433,7 +6266,7 @@ function resolveGqlTemplateText(arg, assembly) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph26.Node.isIdentifier(arg)) {
+  if (!import_ts_morph25.Node.isIdentifier(arg)) {
     return null;
   }
   const symbol = arg.getSymbol();
@@ -6441,7 +6274,7 @@ function resolveGqlTemplateText(arg, assembly) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (import_ts_morph26.Node.isImportClause(decl) || import_ts_morph26.Node.isImportSpecifier(decl)) {
+    if (import_ts_morph25.Node.isImportClause(decl) || import_ts_morph25.Node.isImportSpecifier(decl)) {
       const fromGraphqlFile = resolveGraphqlFileImport(decl);
       if (fromGraphqlFile !== null) {
         return fromGraphqlFile;
@@ -6460,7 +6293,7 @@ function resolveGqlTemplateText(arg, assembly) {
   return null;
 }
 function resolveTypedDocumentSource(arg) {
-  if (!import_ts_morph26.Node.isIdentifier(arg)) {
+  if (!import_ts_morph25.Node.isIdentifier(arg)) {
     return null;
   }
   for (const init of importedVariableInitializers(arg)) {
@@ -6473,7 +6306,7 @@ function resolveTypedDocumentSource(arg) {
 }
 function typedDocumentSourceOf(node) {
   const inner = stripDocumentNodeCasts(node);
-  if (!import_ts_morph26.Node.isObjectLiteralExpression(inner)) {
+  if (!import_ts_morph25.Node.isObjectLiteralExpression(inner)) {
     return null;
   }
   const evaluated = evaluateObjectLiteralAsJson(inner);
@@ -6491,7 +6324,7 @@ function typedDocumentSourceOf(node) {
   }
 }
 function resolveTypedDocumentHeader(arg) {
-  if (!import_ts_morph26.Node.isIdentifier(arg)) {
+  if (!import_ts_morph25.Node.isIdentifier(arg)) {
     return null;
   }
   const reference = arg.getText();
@@ -6501,7 +6334,7 @@ function resolveTypedDocumentHeader(arg) {
   }
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   for (const decl of resolved.getDeclarations()) {
-    if (!import_ts_morph26.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph25.Node.isVariableDeclaration(decl)) {
       continue;
     }
     const init = decl.getInitializer();
@@ -6534,10 +6367,10 @@ function resolveTypedDocumentHeader(arg) {
 }
 function documentNodeCastTypeArgs(node) {
   let current2 = node;
-  while (import_ts_morph26.Node.isAsExpression(current2) || import_ts_morph26.Node.isParenthesizedExpression(current2)) {
-    if (import_ts_morph26.Node.isAsExpression(current2)) {
+  while (import_ts_morph25.Node.isAsExpression(current2) || import_ts_morph25.Node.isParenthesizedExpression(current2)) {
+    if (import_ts_morph25.Node.isAsExpression(current2)) {
       const typeNode = current2.getTypeNode();
-      if (typeNode !== void 0 && import_ts_morph26.Node.isTypeReference(typeNode)) {
+      if (typeNode !== void 0 && import_ts_morph25.Node.isTypeReference(typeNode)) {
         const name = typeNode.getTypeName().getText();
         const simpleName = name.includes(".") ? name.split(".").pop() ?? name : name;
         if (simpleName === "TypedDocumentNode" || simpleName === "DocumentNode") {
@@ -6550,7 +6383,7 @@ function documentNodeCastTypeArgs(node) {
   return null;
 }
 function operationHeaderFromResultType(typeNode) {
-  if (typeNode === void 0 || !import_ts_morph26.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph25.Node.isTypeReference(typeNode)) {
     return null;
   }
   const name = typeNode.getTypeName().getText();
@@ -6571,16 +6404,16 @@ function operationHeaderFromResultType(typeNode) {
 }
 function stripDocumentNodeCasts(node) {
   let current2 = node;
-  while (import_ts_morph26.Node.isAsExpression(current2) || import_ts_morph26.Node.isParenthesizedExpression(current2)) {
+  while (import_ts_morph25.Node.isAsExpression(current2) || import_ts_morph25.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
 }
 function evaluateObjectLiteralAsJson(node) {
-  if (import_ts_morph26.Node.isStringLiteral(node) || import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph25.Node.isStringLiteral(node) || import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
-  if (import_ts_morph26.Node.isNumericLiteral(node)) {
+  if (import_ts_morph25.Node.isNumericLiteral(node)) {
     return Number(node.getText());
   }
   const kind = node.getText();
@@ -6593,17 +6426,17 @@ function evaluateObjectLiteralAsJson(node) {
   if (kind === "null") {
     return null;
   }
-  if (import_ts_morph26.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph25.Node.isObjectLiteralExpression(node)) {
     const out = {};
     for (const prop of node.getProperties()) {
-      if (!import_ts_morph26.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph25.Node.isPropertyAssignment(prop)) {
         return null;
       }
       const nameNode = prop.getNameNode();
       let name;
-      if (import_ts_morph26.Node.isIdentifier(nameNode)) {
+      if (import_ts_morph25.Node.isIdentifier(nameNode)) {
         name = nameNode.getText();
-      } else if (import_ts_morph26.Node.isStringLiteral(nameNode) || import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
+      } else if (import_ts_morph25.Node.isStringLiteral(nameNode) || import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
         name = nameNode.getLiteralValue();
       } else {
         return null;
@@ -6620,7 +6453,7 @@ function evaluateObjectLiteralAsJson(node) {
     }
     return out;
   }
-  if (import_ts_morph26.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph25.Node.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.getElements()) {
       const value = evaluateObjectLiteralAsJson(el);
@@ -6634,8 +6467,8 @@ function evaluateObjectLiteralAsJson(node) {
   return void 0;
 }
 function resolveGraphqlFileImport(decl) {
-  const importDecl = import_ts_morph26.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph26.Node.isImportClause(decl) ? decl.getParent() : null;
-  if (importDecl === null || importDecl === void 0 || !import_ts_morph26.Node.isImportDeclaration(importDecl)) {
+  const importDecl = import_ts_morph25.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph25.Node.isImportClause(decl) ? decl.getParent() : null;
+  if (importDecl === null || importDecl === void 0 || !import_ts_morph25.Node.isImportDeclaration(importDecl)) {
     return null;
   }
   const specifier = importDecl.getModuleSpecifierValue();
@@ -6643,8 +6476,8 @@ function resolveGraphqlFileImport(decl) {
     return null;
   }
   const sourceFile = importDecl.getSourceFile();
-  const baseDir = import_node_path4.default.dirname(sourceFile.getFilePath());
-  const absolute = import_node_path4.default.resolve(baseDir, specifier);
+  const baseDir = import_node_path3.default.dirname(sourceFile.getFilePath());
+  const absolute = import_node_path3.default.resolve(baseDir, specifier);
   try {
     return import_node_fs.default.readFileSync(absolute, "utf8");
   } catch {
@@ -6654,7 +6487,7 @@ function resolveGraphqlFileImport(decl) {
 function enclosingFunctionRoot(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph26.Node.isFunctionDeclaration(current2) || import_ts_morph26.Node.isFunctionExpression(current2) || import_ts_morph26.Node.isArrowFunction(current2) || import_ts_morph26.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph25.Node.isFunctionDeclaration(current2) || import_ts_morph25.Node.isFunctionExpression(current2) || import_ts_morph25.Node.isArrowFunction(current2) || import_ts_morph25.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -6662,18 +6495,18 @@ function enclosingFunctionRoot(node) {
   return null;
 }
 function functionNameOrAnon(func) {
-  if (import_ts_morph26.Node.isFunctionDeclaration(func) || import_ts_morph26.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph25.Node.isFunctionDeclaration(func) || import_ts_morph25.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "<anon>";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph26.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph25.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return "<anon>";
 }
 
 // src/discovery/importedCalls.ts
-var import_ts_morph27 = require("ts-morph");
+var import_ts_morph26 = require("ts-morph");
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6687,11 +6520,11 @@ function callsResolvingTo(sourceFile, resolution, spec) {
 function callsByOriginName(sourceFile, resolution, module2, names) {
   const candidates = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph27.Node.isCallExpression(node) && !import_ts_morph27.Node.isNewExpression(node)) {
+    if (!import_ts_morph26.Node.isCallExpression(node) && !import_ts_morph26.Node.isNewExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph27.Node.isIdentifier(callee) && !declaredLocally(callee)) {
+    if (import_ts_morph26.Node.isIdentifier(callee) && !declaredLocally(callee)) {
       candidates.push(node);
     }
   });
@@ -6717,7 +6550,7 @@ function callsByOriginName(sourceFile, resolution, module2, names) {
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
   return declarations.length > 0 && declarations.every(
-    (declaration) => (import_ts_morph27.Node.isFunctionDeclaration(declaration) || import_ts_morph27.Node.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
+    (declaration) => (import_ts_morph26.Node.isFunctionDeclaration(declaration) || import_ts_morph26.Node.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
   );
 }
 
@@ -6735,7 +6568,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
   );
   const results = [];
   for (const [node, canonical] of hookCalls) {
-    if (!import_ts_morph28.Node.isCallExpression(node)) {
+    if (!import_ts_morph27.Node.isCallExpression(node)) {
       continue;
     }
     const operationType = operationTypeByHook.get(canonical);
@@ -6772,7 +6605,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlImperativeCall.ts
-var import_ts_morph29 = require("ts-morph");
+var import_ts_morph28 = require("ts-morph");
 function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   const isTheClient = clientReceiverCheckFor(sourceFile, match, resolution);
   const methodSpec = /* @__PURE__ */ new Map();
@@ -6784,11 +6617,11 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph29.Node.isCallExpression(node)) {
+    if (!import_ts_morph28.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph29.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph28.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -6800,7 +6633,7 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph29.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph28.Node.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -6836,16 +6669,16 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   return results;
 }
 function imperativeConfigValue(prop) {
-  if (import_ts_morph29.Node.isPropertyAssignment(prop)) {
+  if (import_ts_morph28.Node.isPropertyAssignment(prop)) {
     return prop.getInitializer() ?? null;
   }
-  if (import_ts_morph29.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph28.Node.isShorthandPropertyAssignment(prop)) {
     const valueSymbol = prop.getValueSymbol();
     if (valueSymbol === void 0) {
       return null;
     }
     for (const decl of valueSymbol.getDeclarations()) {
-      if (import_ts_morph29.Node.isVariableDeclaration(decl)) {
+      if (import_ts_morph28.Node.isVariableDeclaration(decl)) {
         const init = decl.getInitializer();
         if (init !== void 0) {
           return init;
@@ -6858,7 +6691,7 @@ function imperativeConfigValue(prop) {
 }
 
 // src/discovery/jsxElementRoute.ts
-var import_ts_morph30 = require("ts-morph");
+var import_ts_morph29 = require("ts-morph");
 var PATH_NOT_LITERAL = "The path this route declares is not written as a string literal, so no path is claimed and this route pairs with nothing";
 var ENCLOSING_PATH_NOT_LITERAL = "A route this one is nested under declares its path as something other than a string literal, so the full path is not claimed and this route pairs with nothing";
 var SPREAD_NOT_ENUMERATED = "A spread stands in for routes declared elsewhere in this array, and they are not read here, so no path is claimed for any of them";
@@ -6890,7 +6723,7 @@ function discoverJsxElementRoutes(sourceFile, match, kind, resolution) {
       }
       return;
     }
-    if (import_ts_morph30.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
+    if (import_ts_morph29.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
       results.push(
         ...unitsForRouteArray(node, match, elementsNames, kind, resolution)
       );
@@ -6912,7 +6745,7 @@ function localNamesFor(sourceFile, match, exported) {
   return local;
 }
 function asRouteJsx(node, routeNames) {
-  if (!import_ts_morph30.Node.isJsxSelfClosingElement(node) && !import_ts_morph30.Node.isJsxElement(node)) {
+  if (!import_ts_morph29.Node.isJsxSelfClosingElement(node) && !import_ts_morph29.Node.isJsxElement(node)) {
     return null;
   }
   return isRouteJsx(node, routeNames) ? node : null;
@@ -6922,15 +6755,15 @@ function isRouteJsx(node, routeNames) {
   return tag !== null && routeNames.has(tag.getText());
 }
 function tagNameOf(node) {
-  const tag = import_ts_morph30.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
-  return import_ts_morph30.Node.isIdentifier(tag) ? tag : null;
+  const tag = import_ts_morph29.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
+  return import_ts_morph29.Node.isIdentifier(tag) ? tag : null;
 }
 function attributesOf(node) {
-  return import_ts_morph30.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
+  return import_ts_morph29.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
 }
 function attributeValueOf(node, name) {
   for (const attribute of attributesOf(node)) {
-    if (!import_ts_morph30.Node.isJsxAttribute(attribute)) {
+    if (!import_ts_morph29.Node.isJsxAttribute(attribute)) {
       continue;
     }
     if (attribute.getNameNode().getText() !== name) {
@@ -6941,8 +6774,8 @@ function attributeValueOf(node, name) {
   return null;
 }
 function literalStringOf2(value) {
-  const unwrapped2 = import_ts_morph30.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (import_ts_morph30.Node.isStringLiteral(unwrapped2) || import_ts_morph30.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  const unwrapped2 = import_ts_morph29.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (import_ts_morph29.Node.isStringLiteral(unwrapped2) || import_ts_morph29.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return unwrapped2.getLiteralValue();
   }
   return null;
@@ -6962,8 +6795,8 @@ function elementTargetOfValue(value) {
   if (value === null) {
     return { kind: "absent" };
   }
-  const unwrapped2 = import_ts_morph30.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (!import_ts_morph30.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph30.Node.isJsxElement(unwrapped2)) {
+  const unwrapped2 = import_ts_morph29.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (!import_ts_morph29.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph29.Node.isJsxElement(unwrapped2)) {
     return { kind: "unreadable" };
   }
   const tag = tagNameOf(unwrapped2);
@@ -6975,7 +6808,7 @@ function elementTargetOfValue(value) {
 function composedPrefixOf(node, match, routeNames) {
   const enclosing = [];
   for (const ancestor of node.getAncestors()) {
-    if (import_ts_morph30.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
+    if (import_ts_morph29.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
       enclosing.push(ancestor);
     }
   }
@@ -7091,14 +6924,14 @@ function abstention(at, kind, sentence, label) {
 }
 function callsAFactory(call, factoryNames) {
   const callee = call.getExpression();
-  return import_ts_morph30.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
+  return import_ts_morph29.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
 }
 function unitsForRouteArray(call, match, elementsNames, kind, resolution) {
   const first = call.getArguments()[0];
   if (first === void 0) {
     return [];
   }
-  if (import_ts_morph30.Node.isJsxElement(first) || import_ts_morph30.Node.isJsxSelfClosingElement(first) || import_ts_morph30.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
+  if (import_ts_morph29.Node.isJsxElement(first) || import_ts_morph29.Node.isJsxSelfClosingElement(first) || import_ts_morph29.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
     return [];
   }
   const array = arrayLiteralOf(first, resolution);
@@ -7123,7 +6956,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
   const nestedIn = new Set(ancestry).add(array);
   const results = [];
   for (const element of array.getElements()) {
-    if (import_ts_morph30.Node.isSpreadElement(element)) {
+    if (import_ts_morph29.Node.isSpreadElement(element)) {
       results.push(
         abstention(
           element,
@@ -7134,7 +6967,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
       );
       continue;
     }
-    if (!import_ts_morph30.Node.isObjectLiteralExpression(element)) {
+    if (!import_ts_morph29.Node.isObjectLiteralExpression(element)) {
       results.push(
         abstention(
           element,
@@ -7223,7 +7056,7 @@ function ownPathOfObject(object, match) {
   }
   if (match.indexAttribute !== void 0) {
     const indexValue = routePropertyOf(object, match.indexAttribute);
-    if (indexValue !== null && import_ts_morph30.Node.isTrueLiteral(indexValue)) {
+    if (indexValue !== null && import_ts_morph29.Node.isTrueLiteral(indexValue)) {
       return { kind: "inherited" };
     }
   }
@@ -7237,27 +7070,27 @@ function objectLabelOf(target) {
   return target.kind === "named" ? target.identifier.getText() : "declaration";
 }
 function labelOfExpression(node) {
-  if (import_ts_morph30.Node.isIdentifier(node)) {
+  if (import_ts_morph29.Node.isIdentifier(node)) {
     return node.getText();
   }
-  if (import_ts_morph30.Node.isCallExpression(node)) {
+  if (import_ts_morph29.Node.isCallExpression(node)) {
     return node.getExpression().getText();
   }
   return node.getKindName();
 }
 
 // src/discovery/packageExports.ts
-var import_ts_morph32 = require("ts-morph");
+var import_ts_morph31 = require("ts-morph");
 
 // src/packageExports.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 function resolvePackageExports(packageJsonPath, opts = {}) {
-  const absPkgJson = import_node_path5.default.resolve(packageJsonPath);
-  const pkgDir = import_node_path5.default.dirname(absPkgJson);
+  const absPkgJson = import_node_path4.default.resolve(packageJsonPath);
+  const pkgDir = import_node_path4.default.dirname(absPkgJson);
   const raw = import_node_fs2.default.readFileSync(absPkgJson, "utf8");
   const pkg = JSON.parse(raw);
-  const packageName = pkg.name ?? import_node_path5.default.basename(pkgDir);
+  const packageName = pkg.name ?? import_node_path4.default.basename(pkgDir);
   const warnings = [];
   const entries = [];
   const pushEntry = (subPath, distPath) => {
@@ -7276,7 +7109,7 @@ function resolvePackageExports(packageJsonPath, opts = {}) {
       subPath,
       exportPathPrefix: subPathToPrefix(subPath),
       sourceFile: src,
-      publishedFile: import_node_path5.default.resolve(pkgDir, distPath)
+      publishedFile: import_node_path4.default.resolve(pkgDir, distPath)
     });
   };
   const exportsField = pkg.exports;
@@ -7318,12 +7151,12 @@ function resolvePackageExportsCached(packageJsonPath) {
   return fresh;
 }
 function namedPackageDirAbove(start) {
-  let at = import_node_path5.default.resolve(start);
+  let at = import_node_path4.default.resolve(start);
   for (let up = 0; up < 12; up += 1) {
     if (packageNameAt(at) !== null) {
       return at;
     }
-    const parent = import_node_path5.default.dirname(at);
+    const parent = import_node_path4.default.dirname(at);
     if (parent === at) {
       break;
     }
@@ -7334,7 +7167,7 @@ function namedPackageDirAbove(start) {
 function packageNameAt(dir) {
   try {
     const manifest = JSON.parse(
-      import_node_fs2.default.readFileSync(import_node_path5.default.join(dir, "package.json"), "utf8")
+      import_node_fs2.default.readFileSync(import_node_path4.default.join(dir, "package.json"), "utf8")
     );
     if (typeof manifest.name === "string" && manifest.name.length > 0) {
       return manifest.name;
@@ -7384,7 +7217,7 @@ function resolveSourceFor(pkgDir, distPath, srcRoot) {
   const stem = withoutDist.replace(/\.d\.ts$/, "").replace(/\.js$/, "").replace(/\.cjs$/, "").replace(/\.mjs$/, "").replace(/\.ts$/, "");
   const candidates = [`${stem}.ts`, `${stem}.tsx`];
   for (const candidate of candidates) {
-    const abs = import_node_path5.default.resolve(pkgDir, candidate);
+    const abs = import_node_path4.default.resolve(pkgDir, candidate);
     if (import_node_fs2.default.existsSync(abs)) {
       return abs;
     }
@@ -7393,20 +7226,20 @@ function resolveSourceFor(pkgDir, distPath, srcRoot) {
 }
 
 // src/resolve/sourceDeclaration.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 function sourceDeclarationsBehind(decl, resolution, visited = /* @__PURE__ */ new Set()) {
   const file = decl.getSourceFile();
   if (!file.isDeclarationFile() || file.isInNodeModules()) {
     return [decl];
   }
-  const packageDir = namedPackageDirAbove(import_node_path6.default.dirname(file.getFilePath()));
+  const packageDir = namedPackageDirAbove(import_node_path5.default.dirname(file.getFilePath()));
   if (packageDir === null || visited.has(packageDir)) {
     return [decl];
   }
   visited.add(packageDir);
   const project = file.getProject();
   const { entries } = resolvePackageExportsCached(
-    import_node_path6.default.join(packageDir, "package.json")
+    import_node_path5.default.join(packageDir, "package.json")
   );
   const found = [];
   for (const entry of entries) {
@@ -7439,13 +7272,13 @@ function sameDeclaration(a, b) {
 }
 
 // src/discovery/factorySurface.ts
-var import_ts_morph31 = require("ts-morph");
+var import_ts_morph30 = require("ts-morph");
 var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl) {
-  if (import_ts_morph31.Node.isClassDeclaration(decl)) {
+  if (import_ts_morph30.Node.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
   }
-  if (import_ts_morph31.Node.isFunctionDeclaration(decl) || import_ts_morph31.Node.isFunctionExpression(decl) || import_ts_morph31.Node.isArrowFunction(decl) || import_ts_morph31.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph30.Node.isFunctionDeclaration(decl) || import_ts_morph30.Node.isFunctionExpression(decl) || import_ts_morph30.Node.isArrowFunction(decl) || import_ts_morph30.Node.isMethodDeclaration(decl)) {
     return surfaceFactoryReturnMethods(decl);
   }
   return [];
@@ -7454,7 +7287,7 @@ function surfaceClassMethods(cls) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const method of cls.getInstanceMethods()) {
-    if (method.hasModifier(import_ts_morph31.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph30.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -7465,7 +7298,7 @@ function surfaceClassMethods(cls) {
     out.push({ func: method, name });
   }
   for (const method of cls.getStaticMethods()) {
-    if (method.hasModifier(import_ts_morph31.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph30.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -7484,9 +7317,9 @@ function surfaceFactoryReturnMethods(fn) {
   return out;
 }
 function collectFromFunctionReturns(fn, out, seen, depth) {
-  if (import_ts_morph31.Node.isArrowFunction(fn)) {
+  if (import_ts_morph30.Node.isArrowFunction(fn)) {
     const body2 = fn.getBody();
-    if (import_ts_morph31.Node.isExpression(body2)) {
+    if (import_ts_morph30.Node.isExpression(body2)) {
       collectFromReturnValue(body2, out, seen, depth);
       return;
     }
@@ -7497,11 +7330,11 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
   }
   const returns = [];
   body.forEachDescendant((node, traversal) => {
-    if (import_ts_morph31.Node.isFunctionDeclaration(node) || import_ts_morph31.Node.isFunctionExpression(node) || import_ts_morph31.Node.isArrowFunction(node) || import_ts_morph31.Node.isMethodDeclaration(node) || import_ts_morph31.Node.isConstructorDeclaration(node) || import_ts_morph31.Node.isGetAccessorDeclaration(node) || import_ts_morph31.Node.isSetAccessorDeclaration(node)) {
+    if (import_ts_morph30.Node.isFunctionDeclaration(node) || import_ts_morph30.Node.isFunctionExpression(node) || import_ts_morph30.Node.isArrowFunction(node) || import_ts_morph30.Node.isMethodDeclaration(node) || import_ts_morph30.Node.isConstructorDeclaration(node) || import_ts_morph30.Node.isGetAccessorDeclaration(node) || import_ts_morph30.Node.isSetAccessorDeclaration(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph31.Node.isReturnStatement(node)) {
+    if (import_ts_morph30.Node.isReturnStatement(node)) {
       returns.push(node);
     }
   });
@@ -7515,15 +7348,15 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
 }
 function collectFromReturnValue(node, out, seen, depth) {
   const expr = peelParens(node);
-  if (import_ts_morph31.Node.isObjectLiteralExpression(expr)) {
+  if (import_ts_morph30.Node.isObjectLiteralExpression(expr)) {
     collectFromObjectLiteral(expr, out, seen);
     return;
   }
-  if (depth >= MAX_BUILDER_HOPS || !import_ts_morph31.Node.isCallExpression(expr)) {
+  if (depth >= MAX_BUILDER_HOPS || !import_ts_morph30.Node.isCallExpression(expr)) {
     return;
   }
   const callee = expr.getExpression();
-  if (!import_ts_morph31.Node.isIdentifier(callee)) {
+  if (!import_ts_morph30.Node.isIdentifier(callee)) {
     return;
   }
   const helper = sameFileFunctionBehind(callee);
@@ -7546,12 +7379,12 @@ function functionAmong(declarations, filePath) {
     if (decl.getSourceFile().getFilePath() !== filePath) {
       continue;
     }
-    if (import_ts_morph31.Node.isFunctionDeclaration(decl)) {
+    if (import_ts_morph30.Node.isFunctionDeclaration(decl)) {
       return decl;
     }
-    if (import_ts_morph31.Node.isVariableDeclaration(decl)) {
+    if (import_ts_morph30.Node.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
-      if (init !== void 0 && (import_ts_morph31.Node.isArrowFunction(init) || import_ts_morph31.Node.isFunctionExpression(init))) {
+      if (init !== void 0 && (import_ts_morph30.Node.isArrowFunction(init) || import_ts_morph30.Node.isFunctionExpression(init))) {
         return init;
       }
     }
@@ -7560,11 +7393,11 @@ function functionAmong(declarations, filePath) {
 }
 function collectFromObjectLiteral(node, out, seen) {
   const e = peelParens(node);
-  if (!import_ts_morph31.Node.isObjectLiteralExpression(e)) {
+  if (!import_ts_morph30.Node.isObjectLiteralExpression(e)) {
     return;
   }
   for (const prop of e.getProperties()) {
-    if (import_ts_morph31.Node.isMethodDeclaration(prop)) {
+    if (import_ts_morph30.Node.isMethodDeclaration(prop)) {
       const name = prop.getName();
       if (seen.has(name)) {
         continue;
@@ -7573,16 +7406,16 @@ function collectFromObjectLiteral(node, out, seen) {
       out.push({ func: prop, name });
       continue;
     }
-    if (import_ts_morph31.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph30.Node.isPropertyAssignment(prop)) {
       const init = prop.getInitializer();
       if (init === void 0) {
         continue;
       }
       let v3 = init;
-      while (import_ts_morph31.Node.isParenthesizedExpression(v3)) {
+      while (import_ts_morph30.Node.isParenthesizedExpression(v3)) {
         v3 = v3.getExpression();
       }
-      if (import_ts_morph31.Node.isArrowFunction(v3) || import_ts_morph31.Node.isFunctionExpression(v3)) {
+      if (import_ts_morph30.Node.isArrowFunction(v3) || import_ts_morph30.Node.isFunctionExpression(v3)) {
         const name = prop.getName();
         if (seen.has(name)) {
           continue;
@@ -7591,7 +7424,7 @@ function collectFromObjectLiteral(node, out, seen) {
         out.push({ func: v3, name });
       }
     }
-    if (import_ts_morph31.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph30.Node.isShorthandPropertyAssignment(prop)) {
       collectShorthandFunction(prop, out, seen);
     }
   }
@@ -7654,9 +7487,9 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
         (decl) => sourceDeclarationsBehind(decl, resolution)
       );
       for (const decl of candidates) {
-        if (import_ts_morph32.Node.isVariableDeclaration(decl)) {
+        if (import_ts_morph31.Node.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
-          if (init !== void 0 && (import_ts_morph32.Node.isArrowFunction(init) || import_ts_morph32.Node.isFunctionExpression(init))) {
+          if (init !== void 0 && (import_ts_morph31.Node.isArrowFunction(init) || import_ts_morph31.Node.isFunctionExpression(init))) {
             results.push(buildUnit(init, kind, exportName, entry));
             for (const m of surfaceMethods(init)) {
               results.push(buildSurfacedUnit(m, kind, exportName, entry));
@@ -7666,7 +7499,7 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
           }
           continue;
         }
-        if (import_ts_morph32.Node.isClassDeclaration(decl)) {
+        if (import_ts_morph31.Node.isClassDeclaration(decl)) {
           for (const m of surfaceMethods(decl)) {
             results.push(buildSurfacedUnit(m, kind, exportName, entry));
           }
@@ -7711,7 +7544,7 @@ function buildSurfacedUnit(m, kind, parentExportName, entry) {
 }
 
 // src/discovery/packageImport.ts
-var import_ts_morph33 = require("ts-morph");
+var import_ts_morph32 = require("ts-morph");
 function isLanguageLib(file) {
   return /[\\/]typescript[\\/]lib[\\/]lib\..*\.d\.ts$/.test(file.getFilePath());
 }
@@ -7732,13 +7565,13 @@ function splitPackageSpec(spec) {
   };
 }
 function enclosingFunctionName(func) {
-  if (import_ts_morph33.Node.isFunctionDeclaration(func) || import_ts_morph33.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph32.Node.isFunctionDeclaration(func) || import_ts_morph32.Node.isMethodDeclaration(func)) {
     const n = func.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph33.Node.isFunctionExpression(func)) {
+  if (import_ts_morph32.Node.isFunctionExpression(func)) {
     const n = func.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
@@ -7746,10 +7579,10 @@ function enclosingFunctionName(func) {
   }
   const parent = func.getParent();
   if (parent !== void 0) {
-    if (import_ts_morph33.Node.isVariableDeclaration(parent)) {
+    if (import_ts_morph32.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
-    if (import_ts_morph33.Node.isPropertyAssignment(parent)) {
+    if (import_ts_morph32.Node.isPropertyAssignment(parent)) {
       return parent.getName();
     }
   }
@@ -7768,7 +7601,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   const calls = [];
   const candidates = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph33.Node.isCallExpression(node)) {
+    if (!import_ts_morph32.Node.isCallExpression(node)) {
       return;
     }
     calls.push(node);
@@ -7776,7 +7609,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (couldBePackageLinked(callee, packages)) {
       candidates.add(callee);
     }
-    if (import_ts_morph33.Node.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
+    if (import_ts_morph32.Node.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
       candidates.add(callee.getExpression());
     }
   });
@@ -7798,7 +7631,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (direct !== null) {
       return direct;
     }
-    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph32.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     const subject = originOf(callee.getExpression());
@@ -7823,7 +7656,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   return results;
 }
 function couldBePackageLinked(value, packages) {
-  if (!import_ts_morph33.Node.isIdentifier(value)) {
+  if (!import_ts_morph32.Node.isIdentifier(value)) {
     return true;
   }
   const declarations = value.getSymbol()?.getDeclarations() ?? [];
@@ -7831,7 +7664,7 @@ function couldBePackageLinked(value, packages) {
     return true;
   }
   return !declarations.every(
-    (declaration) => import_ts_morph33.Node.isFunctionDeclaration(declaration) || import_ts_morph33.Node.isMethodDeclaration(declaration) || import_ts_morph33.Node.isClassDeclaration(declaration) || import_ts_morph33.Node.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
+    (declaration) => import_ts_morph32.Node.isFunctionDeclaration(declaration) || import_ts_morph32.Node.isMethodDeclaration(declaration) || import_ts_morph32.Node.isClassDeclaration(declaration) || import_ts_morph32.Node.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
   );
 }
 function importAimsElsewhere(declaration, packages) {
@@ -7884,7 +7717,7 @@ function discoverPackageImports(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/registrationCall.ts
-var import_ts_morph34 = require("ts-morph");
+var import_ts_morph33 = require("ts-morph");
 var import_resolution3 = require("@suss/resolution");
 
 // src/resolve/routePath.ts
@@ -7909,11 +7742,11 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph33.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -7950,12 +7783,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     const registrationSubjectId = nodeId(subjectNode);
     let foundObjectArg = false;
     for (const arg of args) {
-      if (!import_ts_morph34.Node.isObjectLiteralExpression(arg)) {
+      if (!import_ts_morph33.Node.isObjectLiteralExpression(arg)) {
         continue;
       }
       foundObjectArg = true;
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph34.Node.isMethodDeclaration(prop)) {
+        if (import_ts_morph33.Node.isMethodDeclaration(prop)) {
           results.push({
             func: prop,
             kind,
@@ -7964,7 +7797,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           });
           continue;
         }
-        if (!import_ts_morph34.Node.isPropertyAssignment(prop)) {
+        if (!import_ts_morph33.Node.isPropertyAssignment(prop)) {
           continue;
         }
         const propInit = prop.getInitializer();
@@ -8077,13 +7910,13 @@ function subjectNodeFor(subject, subjects, match, resolution) {
 }
 var NOT_A_ROUTABLE = { kind: "none" };
 function receiverOf(subject, subjects, match, resolution) {
-  if (import_ts_morph34.Node.isIdentifier(subject)) {
+  if (import_ts_morph33.Node.isIdentifier(subject)) {
     const known = subjects.get(subject.getText());
     if (known !== void 0) {
       return { kind: "routable", node: known };
     }
   }
-  if (resolution === void 0 || !(import_ts_morph34.Node.isIdentifier(subject) || import_ts_morph34.Node.isPropertyAccessExpression(subject))) {
+  if (resolution === void 0 || !(import_ts_morph33.Node.isIdentifier(subject) || import_ts_morph33.Node.isPropertyAccessExpression(subject))) {
     return NOT_A_ROUTABLE;
   }
   const construction = resolution.subjectConstructionOf(
@@ -8123,18 +7956,18 @@ function collectMethodsCalledOnCallResults(sourceFile) {
   const setToCalls = /* @__PURE__ */ new Set();
   const calledOn = /* @__PURE__ */ new Map();
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph34.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph33.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && import_ts_morph34.Node.isCallExpression(init)) {
+      if (init !== void 0 && import_ts_morph33.Node.isCallExpression(init)) {
         setToCalls.add(node.getName());
       }
       return;
     }
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph33.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) || !import_ts_morph34.Node.isIdentifier(callee.getExpression())) {
+    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee) || !import_ts_morph33.Node.isIdentifier(callee.getExpression())) {
       return;
     }
     const receiver = callee.getExpression().getText();
@@ -8161,18 +7994,18 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
     return subjects;
   }
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph34.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph33.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
       if (init === void 0) {
         return;
       }
-      const calleeText = import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init) ? init.getExpression().getText() : null;
+      const calleeText = import_ts_morph33.Node.isCallExpression(init) || import_ts_morph33.Node.isNewExpression(init) ? init.getExpression().getText() : null;
       if (calleeText !== null && spellings.includes(calleeText)) {
         subjects.set(node.getName(), init);
       }
       return;
     }
-    if (!import_ts_morph34.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph33.Node.isParameterDeclaration(node)) {
       return;
     }
     const typeNode = node.getTypeNode();
@@ -8193,7 +8026,7 @@ function creationSiteBehind(parameter, resolution) {
     return parameter;
   }
   const written = resolution.resolveWrittenValue(parameter);
-  if (written === null || !(import_ts_morph34.Node.isCallExpression(written) || import_ts_morph34.Node.isNewExpression(written))) {
+  if (written === null || !(import_ts_morph33.Node.isCallExpression(written) || import_ts_morph33.Node.isNewExpression(written))) {
     return parameter;
   }
   return written;
@@ -8236,7 +8069,7 @@ function unboundConstructionsOf(sourceFile, importModule, importName) {
   }
   const constructions = [];
   sourceFile.forEachDescendant((node) => {
-    if ((import_ts_morph34.Node.isCallExpression(node) || import_ts_morph34.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph34.Node.isVariableDeclaration(node.getParent())) {
+    if ((import_ts_morph33.Node.isCallExpression(node) || import_ts_morph33.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph33.Node.isVariableDeclaration(node.getParent())) {
       constructions.push(node);
     }
   });
@@ -8254,11 +8087,11 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
   }
   const edges = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph33.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
+    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -8272,7 +8105,7 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
     }
     const args = node.getArguments();
     const prefixArg = args[mount.prefixPosition];
-    if (prefixArg === void 0 || !(import_ts_morph34.Node.isStringLiteral(prefixArg) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
+    if (prefixArg === void 0 || !(import_ts_morph33.Node.isStringLiteral(prefixArg) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
       return;
     }
     const targetNodes = mountTargetsAmong(
@@ -8327,7 +8160,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
   } else {
     const args = call.getArguments();
     const arg = args[binding.method.position];
-    if (arg === void 0 || !(import_ts_morph34.Node.isStringLiteral(arg) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(arg))) {
+    if (arg === void 0 || !(import_ts_morph33.Node.isStringLiteral(arg) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(arg))) {
       return null;
     }
     method = arg.getLiteralValue().toUpperCase();
@@ -8338,7 +8171,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
 }
 
 // src/discovery/registrationLoop.ts
-var import_ts_morph35 = require("ts-morph");
+var import_ts_morph34 = require("ts-morph");
 function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
   const results = [];
   const guard = receiverGuard(sourceFile, match.receiver, resolution);
@@ -8346,7 +8179,7 @@ function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph35.Node.isForOfStatement(node)) {
+    if (!import_ts_morph34.Node.isForOfStatement(node)) {
       return;
     }
     const expanded = tryExpandLoop(node, match, kind, resolution, guard);
@@ -8409,13 +8242,13 @@ function tryExpandLoop(loop, match, kind, resolution, guard) {
 }
 function loopVariableName(loop) {
   const initializer = loop.getInitializer();
-  if (import_ts_morph35.Node.isVariableDeclarationList(initializer)) {
+  if (import_ts_morph34.Node.isVariableDeclarationList(initializer)) {
     const decls = initializer.getDeclarations();
     if (decls.length !== 1) {
       return null;
     }
     const nameNode = decls[0]?.getNameNode();
-    if (nameNode !== void 0 && import_ts_morph35.Node.isIdentifier(nameNode)) {
+    if (nameNode !== void 0 && import_ts_morph34.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -8428,14 +8261,14 @@ function bodyReferencesLoopVar(loop, name) {
     if (referenced) {
       return;
     }
-    if (!import_ts_morph35.Node.isCallExpression(node)) {
+    if (!import_ts_morph34.Node.isCallExpression(node)) {
       return;
     }
     node.forEachDescendant((inner) => {
       if (referenced) {
         return;
       }
-      if (import_ts_morph35.Node.isIdentifier(inner) && inner.getText() === name) {
+      if (import_ts_morph34.Node.isIdentifier(inner) && inner.getText() === name) {
         referenced = true;
       }
     });
@@ -8445,11 +8278,11 @@ function bodyReferencesLoopVar(loop, name) {
 function bodyCallsOnRoutable(loop, guard, resolution) {
   let found = false;
   loop.getStatement().forEachDescendant((node) => {
-    if (found || !import_ts_morph35.Node.isCallExpression(node)) {
+    if (found || !import_ts_morph34.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee) && !import_ts_morph35.Node.isElementAccessExpression(callee)) {
+    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) && !import_ts_morph34.Node.isElementAccessExpression(callee)) {
       return;
     }
     const subject = callee.getExpression();
@@ -8469,11 +8302,11 @@ function readRouteSpec(element, shape, resolution) {
   let path15 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
-    if (import_ts_morph35.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
+    if (import_ts_morph34.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
       handler = { func: prop, name: shape.handlerKey };
       continue;
     }
-    if (!import_ts_morph35.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph34.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const name = prop.getName();
@@ -8496,22 +8329,22 @@ function readRouteSpec(element, shape, resolution) {
   return { method, path: path15, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
-  if (import_ts_morph35.Node.isStringLiteral(node) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph34.Node.isStringLiteral(node) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
 }
 function handlerName(value) {
-  return import_ts_morph35.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph34.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 
 // src/discovery/registrationTemplate.ts
-var import_node_path7 = __toESM(require("path"), 1);
-var import_ts_morph37 = require("ts-morph");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_ts_morph36 = require("ts-morph");
 var import_resolution4 = require("@suss/resolution");
 
 // src/resolve/unfollowedCall.ts
-var import_ts_morph36 = require("ts-morph");
+var import_ts_morph35 = require("ts-morph");
 var import_behavioral_ir2 = require("@suss/behavioral-ir");
 function isInExternalCode(sourceFile) {
   if (sourceFile.isDeclarationFile()) {
@@ -8520,38 +8353,38 @@ function isInExternalCode(sourceFile) {
   return sourceFile.getFilePath().includes("/node_modules/");
 }
 function hasBody(fn) {
-  if (import_ts_morph36.Node.isFunctionDeclaration(fn) || import_ts_morph36.Node.isMethodDeclaration(fn) || import_ts_morph36.Node.isFunctionExpression(fn)) {
+  if (import_ts_morph35.Node.isFunctionDeclaration(fn) || import_ts_morph35.Node.isMethodDeclaration(fn) || import_ts_morph35.Node.isFunctionExpression(fn)) {
     return fn.getBody?.() !== void 0;
   }
   return true;
 }
 function isDeclaredShape(declaration) {
-  return (import_ts_morph36.Node.isMethodSignature(declaration) || import_ts_morph36.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+  return (import_ts_morph35.Node.isMethodSignature(declaration) || import_ts_morph35.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
 }
 function isExternalDeclaration(declaration) {
   if (isInExternalCode(declaration.getSourceFile())) {
     return true;
   }
-  if (import_ts_morph36.Node.isImportSpecifier(declaration) || import_ts_morph36.Node.isImportClause(declaration) || import_ts_morph36.Node.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(import_ts_morph36.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+  if (import_ts_morph35.Node.isImportSpecifier(declaration) || import_ts_morph35.Node.isImportClause(declaration) || import_ts_morph35.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph35.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
     return target === void 0 || isInExternalCode(target);
   }
   return declaresAnotherModule(declaration);
 }
 function declaresAnotherModule(declaration) {
   const module2 = declaration.getFirstAncestorByKind(
-    import_ts_morph36.SyntaxKind.ModuleDeclaration
+    import_ts_morph35.SyntaxKind.ModuleDeclaration
   );
-  return module2 !== void 0 && import_ts_morph36.Node.isStringLiteral(module2.getNameNode());
+  return module2 !== void 0 && import_ts_morph35.Node.isStringLiteral(module2.getNameNode());
 }
 function statesShapeOnly(declaration) {
   if (isExternalDeclaration(declaration)) {
     return false;
   }
-  if (import_ts_morph36.Node.isMethodSignature(declaration) || import_ts_morph36.Node.isPropertySignature(declaration)) {
+  if (import_ts_morph35.Node.isMethodSignature(declaration) || import_ts_morph35.Node.isPropertySignature(declaration)) {
     return true;
   }
-  if (import_ts_morph36.Node.isFunctionDeclaration(declaration) || import_ts_morph36.Node.isMethodDeclaration(declaration)) {
+  if (import_ts_morph35.Node.isFunctionDeclaration(declaration) || import_ts_morph35.Node.isMethodDeclaration(declaration)) {
     return declaration.getBody() === void 0;
   }
   return false;
@@ -8564,7 +8397,7 @@ function declarationsBehind(symbol) {
   return behind.length > 0 ? behind : symbol.getDeclarations();
 }
 function isParameterOf(declaration, scanning) {
-  return import_ts_morph36.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
+  return import_ts_morph35.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
 }
 function parameterIndexOf(declarations, scanning) {
   if (scanning === void 0) {
@@ -8656,20 +8489,20 @@ function subjectOfCall(sourceFile, args, match, resolution) {
 }
 function helperCallsOf(sourceFile, match, resolution) {
   const module2 = match.importModule;
-  if (module2 !== void 0 && !import_node_path7.default.isAbsolute(module2)) {
+  if (module2 !== void 0 && !import_node_path6.default.isAbsolute(module2)) {
     const store = resolution ?? new ResolutionStore();
     return callsResolvingTo(sourceFile, store, {
       module: module2,
       name: match.helperName
-    }).filter(import_ts_morph37.Node.isCallExpression);
+    }).filter(import_ts_morph36.Node.isCallExpression);
   }
   const calls = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph37.Node.isCallExpression(node)) {
+    if (!import_ts_morph36.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph37.Node.isIdentifier(callee) || callee.getText() !== match.helperName) {
+    if (!import_ts_morph36.Node.isIdentifier(callee) || callee.getText() !== match.helperName) {
       return;
     }
     if (module2 === void 0 || declaredInModule(callee, module2)) {
@@ -8713,7 +8546,7 @@ function substitutePath(template, args) {
   return result;
 }
 function readStringLiteral(node) {
-  if (import_ts_morph37.Node.isStringLiteral(node) || import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph36.Node.isStringLiteral(node) || import_ts_morph36.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
@@ -8736,7 +8569,7 @@ function resolveHandler(template, args, resolution) {
   return readPropertyAsFunction(arg, prop, resolution);
 }
 function handlerName2(value) {
-  return import_ts_morph37.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph36.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 function readPropertyAsFunction(arg, prop, resolution) {
   const obj = objectLiteralOf(arg, resolution);
@@ -8747,7 +8580,7 @@ function readPropertyAsFunction(arg, prop, resolution) {
     if (propertyName(property) !== prop) {
       continue;
     }
-    if (import_ts_morph37.Node.isMethodDeclaration(property)) {
+    if (import_ts_morph36.Node.isMethodDeclaration(property)) {
       return { func: property, name: prop };
     }
     const held = propertyValueOf(property);
@@ -8755,19 +8588,19 @@ function readPropertyAsFunction(arg, prop, resolution) {
       return null;
     }
     const func = functionValueOf(held, resolution);
-    return func === null ? null : { func, name: import_ts_morph37.Node.isIdentifier(held) ? held.getText() : prop };
+    return func === null ? null : { func, name: import_ts_morph36.Node.isIdentifier(held) ? held.getText() : prop };
   }
   return null;
 }
 function propertyName(property) {
-  if (import_ts_morph37.Node.isPropertyAssignment(property) || import_ts_morph37.Node.isShorthandPropertyAssignment(property) || import_ts_morph37.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph36.Node.isPropertyAssignment(property) || import_ts_morph36.Node.isShorthandPropertyAssignment(property) || import_ts_morph36.Node.isMethodDeclaration(property)) {
     return property.getName();
   }
   return null;
 }
 
 // src/discovery/resolverMap.ts
-var import_ts_morph38 = require("ts-morph");
+var import_ts_morph37 = require("ts-morph");
 function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const store = resolution ?? new ResolutionStore();
   const mapProperty = match.mapProperty;
@@ -8778,7 +8611,7 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
     name: match.importName
   })) {
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph38.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph37.Node.isObjectLiteralExpression(args[0])) {
       continue;
     }
     const config = args[0];
@@ -8832,7 +8665,7 @@ function resolverMapObject(prop, resolution) {
   return held === null ? null : objectLiteralOf(held, resolution);
 }
 function extractTypeDefsSdl(config, resolution) {
-  if (!import_ts_morph38.Node.isObjectLiteralExpression(config)) {
+  if (!import_ts_morph37.Node.isObjectLiteralExpression(config)) {
     return null;
   }
   const prop = config.getProperty("typeDefs");
@@ -8854,15 +8687,15 @@ function schemaSdlOf(expr, resolution) {
   return resolved === null ? null : writtenSdl(resolved);
 }
 function writtenSdl(expr) {
-  if (import_ts_morph38.Node.isStringLiteral(expr) || import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph37.Node.isStringLiteral(expr) || import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(expr)) {
     const value = expr.getLiteralValue();
     return value === "" ? null : value;
   }
-  if (import_ts_morph38.Node.isTaggedTemplateExpression(expr)) {
+  if (import_ts_morph37.Node.isTaggedTemplateExpression(expr)) {
     const tag = expr.getTag();
-    if (import_ts_morph38.Node.isIdentifier(tag) && tag.getText() === "gql") {
+    if (import_ts_morph37.Node.isIdentifier(tag) && tag.getText() === "gql") {
       const template = expr.getTemplate();
-      if (import_ts_morph38.Node.isNoSubstitutionTemplateLiteral(template)) {
+      if (import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(template)) {
         return template.getLiteralValue();
       }
     }
@@ -9025,7 +8858,7 @@ function discoverUnits(sourceFile, patterns, resolution, mountPrefixes, expanded
 // src/resolve/functionBehind.ts
 function symbolBehind(node) {
   const parent = node.getParent();
-  if (parent !== void 0 && import_ts_morph39.Node.isShorthandPropertyAssignment(parent)) {
+  if (parent !== void 0 && import_ts_morph38.Node.isShorthandPropertyAssignment(parent)) {
     return parent.getValueSymbol();
   }
   return node.getSymbol();
@@ -9055,9 +8888,9 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph39.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph38.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph39.Node.isArrowFunction(init) || import_ts_morph39.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph38.Node.isArrowFunction(init) || import_ts_morph38.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
@@ -9065,20 +8898,20 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph39.Node.isFunctionDeclaration(decl) || import_ts_morph39.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph38.Node.isFunctionDeclaration(decl) || import_ts_morph38.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph39.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph38.Node.isFunctionExpression(decl)) {
     const n = decl.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
   const parent = decl.getParent();
-  if (parent !== void 0 && import_ts_morph39.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph38.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
@@ -9090,14 +8923,14 @@ function pathAbove(reference) {
   let current2 = reference;
   for (; ; ) {
     const parent = current2.getParent();
-    if (parent !== void 0 && import_ts_morph40.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
+    if (parent !== void 0 && import_ts_morph39.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
       path15.push(parent.getName());
       current2 = parent;
       continue;
     }
-    if (parent !== void 0 && import_ts_morph40.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
+    if (parent !== void 0 && import_ts_morph39.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
       const argument = parent.getArgumentExpression();
-      if (argument !== void 0 && import_ts_morph40.Node.isStringLiteral(argument)) {
+      if (argument !== void 0 && import_ts_morph39.Node.isStringLiteral(argument)) {
         path15.push(argument.getLiteralValue());
         current2 = parent;
         continue;
@@ -9107,11 +8940,11 @@ function pathAbove(reference) {
   }
 }
 function declaresParameterOf(node, func) {
-  if (import_ts_morph40.Node.isParameterDeclaration(node)) {
+  if (import_ts_morph39.Node.isParameterDeclaration(node)) {
     return node.getParent() === func;
   }
-  if (import_ts_morph40.Node.isBindingElement(node)) {
-    const parameter = node.getFirstAncestor(import_ts_morph40.Node.isParameterDeclaration);
+  if (import_ts_morph39.Node.isBindingElement(node)) {
+    const parameter = node.getFirstAncestor(import_ts_morph39.Node.isParameterDeclaration);
     return parameter !== void 0 && parameter.getParent() === func;
   }
   return false;
@@ -9127,7 +8960,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph40.Node.isIdentifier(node) || !wanted.has(node.getText())) {
+    if (!import_ts_morph39.Node.isIdentifier(node) || !wanted.has(node.getText())) {
       return;
     }
     const declarations = symbolBehind(node)?.getDeclarations() ?? [];
@@ -9150,7 +8983,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
 }
 
 // src/resolve/readName.ts
-var import_ts_morph41 = require("ts-morph");
+var import_ts_morph40 = require("ts-morph");
 var import_behavioral_ir3 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
@@ -9185,11 +9018,11 @@ function referenceIn(expr) {
 function parameterPath(expr) {
   const fields = [];
   let step = expr;
-  while (import_ts_morph41.Node.isPropertyAccessExpression(step)) {
+  while (import_ts_morph40.Node.isPropertyAccessExpression(step)) {
     fields.unshift(step.getName());
     step = step.getExpression();
   }
-  if (!import_ts_morph41.Node.isIdentifier(step) || !isParameter(step)) {
+  if (!import_ts_morph40.Node.isIdentifier(step) || !isParameter(step)) {
     return null;
   }
   return { root: step.getText(), fields };
@@ -9197,7 +9030,7 @@ function parameterPath(expr) {
 function isParameter(identifier) {
   const declarations = identifier.getSymbol()?.getDeclarations() ?? [];
   return declarations.some(
-    (declaration) => import_ts_morph41.Node.isParameterDeclaration(declaration)
+    (declaration) => import_ts_morph40.Node.isParameterDeclaration(declaration)
   );
 }
 function read(expr, ctx) {
@@ -9206,25 +9039,25 @@ function read(expr, ctx) {
   }
   const seen = new Set(ctx.seen).add(expr);
   const inner = { ...ctx, seen };
-  if (import_ts_morph41.Node.isStringLiteral(expr) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph40.Node.isStringLiteral(expr) || import_ts_morph40.Node.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.getLiteralValue();
   }
-  if (import_ts_morph41.Node.isNumericLiteral(expr)) {
+  if (import_ts_morph40.Node.isNumericLiteral(expr)) {
     return expr.getLiteralText();
   }
-  if (import_ts_morph41.Node.isTemplateExpression(expr)) {
+  if (import_ts_morph40.Node.isTemplateExpression(expr)) {
     return fromTemplate(expr, inner);
   }
-  if (import_ts_morph41.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph40.Node.isParenthesizedExpression(expr)) {
     return read(peelParens(expr), inner);
   }
-  if (import_ts_morph41.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph40.Node.isBinaryExpression(expr)) {
     return fromBinary(expr, inner);
   }
-  if (import_ts_morph41.Node.isCallExpression(expr)) {
+  if (import_ts_morph40.Node.isCallExpression(expr)) {
     return fromCall(expr, inner);
   }
-  if (import_ts_morph41.Node.isIdentifier(expr)) {
+  if (import_ts_morph40.Node.isIdentifier(expr)) {
     const only = boundOnce(expr, ctx);
     if (only !== null) {
       return read(only.node, { ...inner, bindings: only.scope });
@@ -9244,17 +9077,17 @@ function read(expr, ctx) {
 }
 function isFallbackBranch(node) {
   let step = node.getParent();
-  while (step !== void 0 && import_ts_morph41.Node.isParenthesizedExpression(step)) {
+  while (step !== void 0 && import_ts_morph40.Node.isParenthesizedExpression(step)) {
     step = step.getParent();
   }
-  if (step === void 0 || !import_ts_morph41.Node.isBinaryExpression(step)) {
+  if (step === void 0 || !import_ts_morph40.Node.isBinaryExpression(step)) {
     return false;
   }
   const operator = step.getOperatorToken().getKind();
-  return operator === import_ts_morph41.SyntaxKind.BarBarToken || operator === import_ts_morph41.SyntaxKind.QuestionQuestionToken;
+  return operator === import_ts_morph40.SyntaxKind.BarBarToken || operator === import_ts_morph40.SyntaxKind.QuestionQuestionToken;
 }
 function fromTemplate(expr, ctx) {
-  if (!import_ts_morph41.Node.isTemplateExpression(expr)) {
+  if (!import_ts_morph40.Node.isTemplateExpression(expr)) {
     return null;
   }
   let name = expr.getHead().getLiteralText();
@@ -9265,28 +9098,28 @@ function fromTemplate(expr, ctx) {
   return name;
 }
 function fromBinary(expr, ctx) {
-  if (!import_ts_morph41.Node.isBinaryExpression(expr)) {
+  if (!import_ts_morph40.Node.isBinaryExpression(expr)) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === import_ts_morph41.SyntaxKind.BarBarToken || operator === import_ts_morph41.SyntaxKind.QuestionQuestionToken) {
+  if (operator === import_ts_morph40.SyntaxKind.BarBarToken || operator === import_ts_morph40.SyntaxKind.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== import_ts_morph41.SyntaxKind.PlusToken) {
+  if (operator !== import_ts_morph40.SyntaxKind.PlusToken) {
     return null;
   }
   const parts = { ...ctx, insideHole: true };
   return readOrHole(expr.getLeft(), parts) + readOrHole(expr.getRight(), parts);
 }
 function fromCall(expr, ctx) {
-  if (!import_ts_morph41.Node.isCallExpression(expr)) {
+  if (!import_ts_morph40.Node.isCallExpression(expr)) {
     return null;
   }
   const callee = expr.getExpression();
-  if (import_ts_morph41.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
+  if (import_ts_morph40.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
     return fromJoin(callee.getExpression(), expr.getArguments(), ctx);
   }
-  if (import_ts_morph41.Node.isIdentifier(callee) && callee.getText() === "String") {
+  if (import_ts_morph40.Node.isIdentifier(callee) && callee.getText() === "String") {
     const only = expr.getArguments()[0];
     return only === void 0 ? null : readOrHole(only, ctx);
   }
@@ -9305,7 +9138,7 @@ function fromCall(expr, ctx) {
 }
 function fromJoin(subject, args, ctx) {
   const separator = args[0];
-  if (separator === void 0 || !import_ts_morph41.Node.isStringLiteral(separator)) {
+  if (separator === void 0 || !import_ts_morph40.Node.isStringLiteral(separator)) {
     return null;
   }
   const parts = elementsOf(subject, ctx);
@@ -9321,17 +9154,17 @@ function fromJoin(subject, args, ctx) {
   ).join(separator.getLiteralValue());
 }
 function elementsOf(subject, ctx) {
-  if (import_ts_morph41.Node.isArrayLiteralExpression(subject)) {
+  if (import_ts_morph40.Node.isArrayLiteralExpression(subject)) {
     return subject.getElements().map((element) => here(element, ctx));
   }
-  if (import_ts_morph41.Node.isCallExpression(subject)) {
+  if (import_ts_morph40.Node.isCallExpression(subject)) {
     const callee = subject.getExpression();
-    if (import_ts_morph41.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
+    if (import_ts_morph40.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
       return elementsOf(callee.getExpression(), ctx);
     }
     return null;
   }
-  if (!import_ts_morph41.Node.isIdentifier(subject)) {
+  if (!import_ts_morph40.Node.isIdentifier(subject)) {
     return null;
   }
   const bound = ctx.bindings.get(subject.getText());
@@ -9339,7 +9172,7 @@ function elementsOf(subject, ctx) {
     return null;
   }
   const only = bound.length === 1 ? bound[0] : void 0;
-  return only !== void 0 && import_ts_morph41.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
+  return only !== void 0 && import_ts_morph40.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
 }
 function singleReturnBody(callee, ctx) {
   const declaration = declarationOf2(callee, ctx);
@@ -9354,22 +9187,22 @@ function singleReturnBody(callee, ctx) {
   if (body === void 0) {
     return null;
   }
-  if (import_ts_morph41.Node.isExpression(body)) {
+  if (import_ts_morph40.Node.isExpression(body)) {
     return { parameters, returned: body };
   }
-  if (!import_ts_morph41.Node.isBlock(body)) {
+  if (!import_ts_morph40.Node.isBlock(body)) {
     return null;
   }
   const statements = body.getStatements();
   const only = statements[0];
-  if (statements.length !== 1 || only === void 0 || !import_ts_morph41.Node.isReturnStatement(only)) {
+  if (statements.length !== 1 || only === void 0 || !import_ts_morph40.Node.isReturnStatement(only)) {
     return null;
   }
   const returned = only.getExpression();
   return returned === void 0 ? null : { parameters, returned };
 }
 function declarationOf2(callee, ctx) {
-  const symbol = import_ts_morph41.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
+  const symbol = import_ts_morph40.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
   const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
   for (const declaration of declarations) {
     const callable = asCallable(declaration);
@@ -9381,14 +9214,14 @@ function declarationOf2(callee, ctx) {
   return written === null || written === callee ? null : declarationOf2(written, { ...ctx, resolve: () => null });
 }
 function asCallable(declaration) {
-  if (import_ts_morph41.Node.isFunctionDeclaration(declaration) || import_ts_morph41.Node.isMethodDeclaration(declaration) || import_ts_morph41.Node.isArrowFunction(declaration) || import_ts_morph41.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph40.Node.isFunctionDeclaration(declaration) || import_ts_morph40.Node.isMethodDeclaration(declaration) || import_ts_morph40.Node.isArrowFunction(declaration) || import_ts_morph40.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (!import_ts_morph41.Node.isVariableDeclaration(declaration)) {
+  if (!import_ts_morph40.Node.isVariableDeclaration(declaration)) {
     return null;
   }
   const initializer = declaration.getInitializer();
-  if (initializer !== void 0 && (import_ts_morph41.Node.isArrowFunction(initializer) || import_ts_morph41.Node.isFunctionExpression(initializer))) {
+  if (initializer !== void 0 && (import_ts_morph40.Node.isArrowFunction(initializer) || import_ts_morph40.Node.isFunctionExpression(initializer))) {
     return initializer;
   }
   return null;
@@ -9410,7 +9243,7 @@ function here(node, ctx) {
   return { node, scope: ctx.bindings };
 }
 function boundOnce(expr, ctx) {
-  const bound = import_ts_morph41.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
+  const bound = import_ts_morph40.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
   return bound !== void 0 && bound.length === 1 ? bound[0] : null;
 }
 function readOrHole(expr, ctx) {
@@ -9422,10 +9255,10 @@ function holeName(expr, ctx) {
   if (bound !== null) {
     return holeName(bound.node, { ...ctx, bindings: bound.scope });
   }
-  if (import_ts_morph41.Node.isIdentifier(expr)) {
+  if (import_ts_morph40.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph41.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph40.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return UNNAMED_HOLE;
@@ -9452,8 +9285,8 @@ function madeFromNamed(origin, made) {
   return origin.named.includes(constructorName(made));
 }
 function constructorName(made) {
-  const expression = import_ts_morph42.Node.isNewExpression(made) || import_ts_morph42.Node.isCallExpression(made) ? made.getExpression() : made;
-  return import_ts_morph42.Node.isPropertyAccessExpression(expression) ? expression.getName() : expression.getText();
+  const expression = import_ts_morph41.Node.isNewExpression(made) || import_ts_morph41.Node.isCallExpression(made) ? made.getExpression() : made;
+  return import_ts_morph41.Node.isPropertyAccessExpression(expression) ? expression.getName() : expression.getText();
 }
 var CALL_ORIGIN = {
   declaredBy: ORIGIN.declaredBy,
@@ -9467,7 +9300,7 @@ var CALL_ORIGIN = {
 };
 function madeBy(receiver) {
   const made = madeExpression(receiver);
-  const expression = import_ts_morph42.Node.isNewExpression(made) || import_ts_morph42.Node.isCallExpression(made) ? made.getExpression() : made;
+  const expression = import_ts_morph41.Node.isNewExpression(made) || import_ts_morph41.Node.isCallExpression(made) ? made.getExpression() : made;
   return rootIdentifier(expression) ?? expression;
 }
 function madeExpression(receiver) {
@@ -9475,7 +9308,7 @@ function madeExpression(receiver) {
     return receiver.expression;
   }
   const written = receiver.resolve(receiver.callee.getExpression());
-  if (written === null || !import_ts_morph42.Node.isNewExpression(written) && !import_ts_morph42.Node.isCallExpression(written)) {
+  if (written === null || !import_ts_morph41.Node.isNewExpression(written) && !import_ts_morph41.Node.isCallExpression(written)) {
     return receiver.callee;
   }
   return written;
@@ -9483,7 +9316,7 @@ function madeExpression(receiver) {
 function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   const resolve2 = resolveWrittenValue ?? (() => null);
   const expression = calleeOf3(call);
-  const callee = import_ts_morph42.Node.isPropertyAccessExpression(expression) ? expression : null;
+  const callee = import_ts_morph41.Node.isPropertyAccessExpression(expression) ? expression : null;
   let args = null;
   const argumentsOf = () => {
     args ??= argumentsIn(call);
@@ -9506,7 +9339,7 @@ function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
     argumentCount: () => argumentsOf().length,
     nameAt: (index, unsettled) => nameAt(argumentsOf()[index], unsettled, resolve2),
     calleeText: () => expression.getText(),
-    namedCallee: () => import_ts_morph42.Node.isIdentifier(expression),
+    namedCallee: () => import_ts_morph41.Node.isIdentifier(expression),
     parameterReadsAt: (index) => selectorReadsOf(argumentsOf()[index]),
     receiver: () => callee === null ? null : opsOverCall(callee.getExpression(), resolve2),
     argument: (index) => opsOverCall(argumentsOf()[index], resolve2),
@@ -9531,7 +9364,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
     return null;
   }
   const found = anchorCallsOf(subject, (candidate) => {
-    if (!import_ts_morph42.Node.isCallExpression(candidate) && !import_ts_morph42.Node.isNewExpression(candidate)) {
+    if (!import_ts_morph41.Node.isCallExpression(candidate) && !import_ts_morph41.Node.isNewExpression(candidate)) {
       return false;
     }
     const candidateCallee = calleeOf3(candidate);
@@ -9546,7 +9379,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
   if (distinct.length !== 1 || only === void 0) {
     return null;
   }
-  if (!import_ts_morph42.Node.isCallExpression(only) && !import_ts_morph42.Node.isNewExpression(only)) {
+  if (!import_ts_morph41.Node.isCallExpression(only) && !import_ts_morph41.Node.isNewExpression(only)) {
     return null;
   }
   return callOpsFor(only, resolve2, originatesFrom, anchorCallsOf);
@@ -9566,7 +9399,7 @@ function valueOpsFor(value, resolve2) {
     asArg: () => effectArgOf(written()),
     property: (name) => {
       const object = written();
-      const inside = import_ts_morph42.Node.isObjectLiteralExpression(object) ? initializerOf(object, name) : null;
+      const inside = import_ts_morph41.Node.isObjectLiteralExpression(object) ? initializerOf(object, name) : null;
       return inside === null ? null : valueOpsFor(inside, resolve2);
     },
     parts: () => literalParts(written()),
@@ -9579,7 +9412,7 @@ function literalParts(value) {
   if (whole !== null) {
     return [whole];
   }
-  if (!import_ts_morph42.Node.isTemplateExpression(written)) {
+  if (!import_ts_morph41.Node.isTemplateExpression(written)) {
     return null;
   }
   return [
@@ -9589,26 +9422,26 @@ function literalParts(value) {
 }
 function templateHoles(value, resolve2) {
   const written = untagged(value);
-  if (!import_ts_morph42.Node.isTemplateExpression(written)) {
+  if (!import_ts_morph41.Node.isTemplateExpression(written)) {
     return [];
   }
   return written.getTemplateSpans().map((span) => opsOverCall(span.getExpression(), resolve2));
 }
 function untagged(value) {
-  return import_ts_morph42.Node.isTaggedTemplateExpression(value) ? value.getTemplate() : value;
+  return import_ts_morph41.Node.isTaggedTemplateExpression(value) ? value.getTemplate() : value;
 }
 function entriesOf(value, unsettled, resolve2) {
-  if (!import_ts_morph42.Node.isObjectLiteralExpression(value)) {
+  if (!import_ts_morph41.Node.isObjectLiteralExpression(value)) {
     return [];
   }
   const found = [];
   for (const written of value.getProperties()) {
-    if (import_ts_morph42.Node.isShorthandPropertyAssignment(written)) {
+    if (import_ts_morph41.Node.isShorthandPropertyAssignment(written)) {
       const name = written.getNameNode();
       found.push({ key: name.getText(), value: valueOpsFor(name, resolve2) });
       continue;
     }
-    if (!import_ts_morph42.Node.isPropertyAssignment(written)) {
+    if (!import_ts_morph41.Node.isPropertyAssignment(written)) {
       continue;
     }
     const stated = written.getInitializer();
@@ -9621,35 +9454,35 @@ function entriesOf(value, unsettled, resolve2) {
 }
 function entryKey(written, unsettled, resolve2) {
   const name = written.getNameNode();
-  if (import_ts_morph42.Node.isComputedPropertyName(name)) {
+  if (import_ts_morph41.Node.isComputedPropertyName(name)) {
     return readName(name.getExpression(), { resolve: resolve2, unsettled });
   }
   return unquoted(written.getName());
 }
 function itemsOf(value, resolve2) {
-  if (!import_ts_morph42.Node.isArrayLiteralExpression(value)) {
+  if (!import_ts_morph41.Node.isArrayLiteralExpression(value)) {
     return [];
   }
   return value.getElements().map((element) => valueOpsFor(element, resolve2));
 }
 function literalText(value) {
-  return import_ts_morph42.Node.isStringLiteral(value) || import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
+  return import_ts_morph41.Node.isStringLiteral(value) || import_ts_morph41.Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
 }
 function literalFlag(value) {
-  if (import_ts_morph42.Node.isTrueLiteral(value) || import_ts_morph42.Node.isFalseLiteral(value)) {
-    return import_ts_morph42.Node.isTrueLiteral(value);
+  if (import_ts_morph41.Node.isTrueLiteral(value) || import_ts_morph41.Node.isFalseLiteral(value)) {
+    return import_ts_morph41.Node.isTrueLiteral(value);
   }
-  return import_ts_morph42.Node.isNumericLiteral(value) ? value.getLiteralValue() !== 0 : null;
+  return import_ts_morph41.Node.isNumericLiteral(value) ? value.getLiteralValue() !== 0 : null;
 }
 function unquoted(name) {
   return name.replace(/^["']|["']$/g, "");
 }
 function selectorReadsOf(argument) {
-  if (argument === void 0 || !import_ts_morph42.Node.isArrowFunction(argument) && !import_ts_morph42.Node.isFunctionExpression(argument)) {
+  if (argument === void 0 || !import_ts_morph41.Node.isArrowFunction(argument) && !import_ts_morph41.Node.isFunctionExpression(argument)) {
     return null;
   }
   const parameter = argument.getParameters()[0];
-  if (parameter === void 0 || !import_ts_morph42.Node.isIdentifier(parameter.getNameNode())) {
+  if (parameter === void 0 || !import_ts_morph41.Node.isIdentifier(parameter.getNameNode())) {
     return null;
   }
   const names = /* @__PURE__ */ new Set();
@@ -9666,17 +9499,17 @@ function opsOverCall(value, resolve2) {
   return callOpsFor(written, resolve2);
 }
 function isCalled(value) {
-  return import_ts_morph42.Node.isCallExpression(value) || import_ts_morph42.Node.isNewExpression(value) || import_ts_morph42.Node.isTaggedTemplateExpression(value);
+  return import_ts_morph41.Node.isCallExpression(value) || import_ts_morph41.Node.isNewExpression(value) || import_ts_morph41.Node.isTaggedTemplateExpression(value);
 }
 function calleeOf3(call) {
-  return import_ts_morph42.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
+  return import_ts_morph41.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
 }
 function argumentsIn(call) {
-  return import_ts_morph42.Node.isTaggedTemplateExpression(call) ? [call.getTemplate()] : call.getArguments();
+  return import_ts_morph41.Node.isTaggedTemplateExpression(call) ? [call.getTemplate()] : call.getArguments();
 }
 function settled(value, resolve2) {
   const step = unwrapped(value ?? null);
-  if (step === null || !import_ts_morph42.Node.isIdentifier(step)) {
+  if (step === null || !import_ts_morph41.Node.isIdentifier(step)) {
     return step;
   }
   return unwrapped(resolve2(step));
@@ -9703,11 +9536,11 @@ function objectAt(argument, resolve2) {
   if (isCalled(written)) {
     return objectAt(argumentsIn(written)[0], resolve2);
   }
-  return import_ts_morph42.Node.isObjectLiteralExpression(written) ? written : null;
+  return import_ts_morph41.Node.isObjectLiteralExpression(written) ? written : null;
 }
 function initializerOf(object, property) {
   for (const written of object.getProperties()) {
-    if (import_ts_morph42.Node.isPropertyAssignment(written) && written.getName() === property) {
+    if (import_ts_morph41.Node.isPropertyAssignment(written) && written.getName() === property) {
       return written.getInitializer() ?? null;
     }
   }
@@ -9737,7 +9570,7 @@ function invocationContextFor(call, resolveWrittenValue, originatesFrom, anchorC
   };
 }
 function isImportedFrom(identifier, expectedModule, originatesFrom) {
-  if (!import_ts_morph43.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph42.Node.isIdentifier(identifier)) {
     return false;
   }
   const symbol = identifier.getSymbol();
@@ -9758,7 +9591,7 @@ function isImportedFrom(identifier, expectedModule, originatesFrom) {
   );
 }
 function methodDeclaredIn(callee, expectedModule, resolve2, originatesFrom) {
-  if (!import_ts_morph43.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph42.Node.isPropertyAccessExpression(callee)) {
     return false;
   }
   const declarations = callee.getNameNode().getSymbol()?.getDeclarations();
@@ -9778,37 +9611,37 @@ function maker(written) {
   if (written === null) {
     return null;
   }
-  if (import_ts_morph43.Node.isNewExpression(written) || import_ts_morph43.Node.isCallExpression(written)) {
+  if (import_ts_morph42.Node.isNewExpression(written) || import_ts_morph42.Node.isCallExpression(written)) {
     return written.getExpression();
   }
   return null;
 }
 function rootIdentifier2(expression) {
   let root = expression;
-  while (import_ts_morph43.Node.isPropertyAccessExpression(root)) {
+  while (import_ts_morph42.Node.isPropertyAccessExpression(root)) {
     root = root.getExpression();
   }
   return root;
 }
 function importSpecifierMatches(decl, expectedModule) {
-  if (import_ts_morph43.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph42.Node.isImportSpecifier(decl)) {
     return decl.getImportDeclaration().getModuleSpecifierValue() === expectedModule;
   }
-  const owner = import_ts_morph43.Node.isNamespaceImport(decl) ? decl.getParent() : decl;
-  if (!import_ts_morph43.Node.isImportClause(owner)) {
+  const owner = import_ts_morph42.Node.isNamespaceImport(decl) ? decl.getParent() : decl;
+  if (!import_ts_morph42.Node.isImportClause(owner)) {
     return false;
   }
   const importDecl = owner.getParent();
-  return import_ts_morph43.Node.isImportDeclaration(importDecl) && importDecl.getModuleSpecifierValue() === expectedModule;
+  return import_ts_morph42.Node.isImportDeclaration(importDecl) && importDecl.getModuleSpecifierValue() === expectedModule;
 }
 function extractInvocationEffects(func, barriers = NO_BARRIERS) {
   const calls = [];
   func.forEachDescendant((node, traversal) => {
-    if (isDescentStop(node, func, barriers) || import_ts_morph43.Node.isDecorator(node)) {
+    if (isDescentStop(node, func, barriers) || import_ts_morph42.Node.isDecorator(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph43.Node.isCallExpression(node)) {
+    if (import_ts_morph42.Node.isCallExpression(node)) {
       calls.push(node);
     }
   });
@@ -9832,10 +9665,10 @@ function invocationAt(call, func) {
 }
 function isAwaited(call) {
   let current2 = call.getParent();
-  while (current2 !== void 0 && import_ts_morph43.Node.isParenthesizedExpression(current2)) {
+  while (current2 !== void 0 && import_ts_morph42.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getParent();
   }
-  return current2 !== void 0 && import_ts_morph43.Node.isAwaitExpression(current2);
+  return current2 !== void 0 && import_ts_morph42.Node.isAwaitExpression(current2);
 }
 function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   if (recognizers.length === 0) {
@@ -9848,7 +9681,7 @@ function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, res
       traversal.skip();
       return;
     }
-    if (!import_ts_morph43.Node.isCallExpression(node)) {
+    if (!import_ts_morph42.Node.isCallExpression(node)) {
       return;
     }
     const ctx = invocationContextFor(
@@ -9910,7 +9743,7 @@ function runAccessRecognizersAtModuleScope(sourceFile, recognizers, resolveWritt
 }
 function accessContextFor(node, sourceFile, resolveWrittenValue = () => null, originatesFrom, anchorCallsOf) {
   const given = { access: node, sourceFile, resolveWrittenValue };
-  if (import_ts_morph43.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph42.Node.isPropertyAccessExpression(node)) {
     return given;
   }
   let ops;
@@ -9939,7 +9772,7 @@ function dispatchAccessRecognizers(root, recognizers, isStop, resolveWrittenValu
       traversal.skip();
       return;
     }
-    if (!import_ts_morph43.Node.isPropertyAccessExpression(node) && !import_ts_morph43.Node.isCallExpression(node) && !import_ts_morph43.Node.isTaggedTemplateExpression(node)) {
+    if (!import_ts_morph42.Node.isPropertyAccessExpression(node) && !import_ts_morph42.Node.isCallExpression(node) && !import_ts_morph42.Node.isTaggedTemplateExpression(node)) {
       return;
     }
     const ctx = accessContextFor(
@@ -9995,35 +9828,35 @@ function extractArg(node, depth) {
       return extractArg(bare, depth);
     }
   }
-  if (import_ts_morph43.Node.isStringLiteral(node) || import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph42.Node.isStringLiteral(node) || import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { kind: "string", value: node.getLiteralValue() };
   }
-  if (import_ts_morph43.Node.isNumericLiteral(node)) {
+  if (import_ts_morph42.Node.isNumericLiteral(node)) {
     return { kind: "number", value: node.getLiteralValue() };
   }
-  if (import_ts_morph43.Node.isTrueLiteral(node)) {
+  if (import_ts_morph42.Node.isTrueLiteral(node)) {
     return { kind: "boolean", value: true };
   }
-  if (import_ts_morph43.Node.isFalseLiteral(node)) {
+  if (import_ts_morph42.Node.isFalseLiteral(node)) {
     return { kind: "boolean", value: false };
   }
-  if (import_ts_morph43.Node.isTemplateExpression(node)) {
+  if (import_ts_morph42.Node.isTemplateExpression(node)) {
     return { kind: "template", sourceText: node.getText() };
   }
-  if (import_ts_morph43.Node.isIdentifier(node)) {
+  if (import_ts_morph42.Node.isIdentifier(node)) {
     const inlined = inlineModuleBinding(node, depth);
     if (inlined !== null) {
       return inlined;
     }
     return { kind: "identifier", name: node.getText() };
   }
-  if (import_ts_morph43.Node.isPropertyAccessExpression(node) || import_ts_morph43.Node.isElementAccessExpression(node)) {
+  if (import_ts_morph42.Node.isPropertyAccessExpression(node) || import_ts_morph42.Node.isElementAccessExpression(node)) {
     return { kind: "identifier", name: node.getText() };
   }
   if (depth <= 0) {
     return null;
   }
-  if (import_ts_morph43.Node.isCallExpression(node)) {
+  if (import_ts_morph42.Node.isCallExpression(node)) {
     const element = mapCallbackReturn(node);
     if (element !== null) {
       return { kind: "array", items: [extractArg(element, depth - 1)] };
@@ -10034,19 +9867,19 @@ function extractArg(node, depth) {
       args: node.getArguments().map((a) => extractArg(a, depth - 1))
     };
   }
-  if (import_ts_morph43.Node.isNewExpression(node)) {
+  if (import_ts_morph42.Node.isNewExpression(node)) {
     return {
       kind: "call",
       callee: node.getExpression().getText(),
       args: node.getArguments().map((a) => extractArg(a, depth - 1))
     };
   }
-  if (import_ts_morph43.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph42.Node.isObjectLiteralExpression(node)) {
     const fields = {};
     for (const prop of node.getProperties()) {
-      if (import_ts_morph43.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph42.Node.isShorthandPropertyAssignment(prop)) {
         const nameNode2 = prop.getNameNode();
-        if (import_ts_morph43.Node.isIdentifier(nameNode2)) {
+        if (import_ts_morph42.Node.isIdentifier(nameNode2)) {
           fields[nameNode2.getText()] = {
             kind: "identifier",
             name: nameNode2.getText()
@@ -10054,14 +9887,14 @@ function extractArg(node, depth) {
         }
         continue;
       }
-      if (!import_ts_morph43.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph42.Node.isPropertyAssignment(prop)) {
         continue;
       }
       const nameNode = prop.getNameNode();
-      if (!import_ts_morph43.Node.isIdentifier(nameNode) && !import_ts_morph43.Node.isStringLiteral(nameNode) && !import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
+      if (!import_ts_morph42.Node.isIdentifier(nameNode) && !import_ts_morph42.Node.isStringLiteral(nameNode) && !import_ts_morph42.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
         continue;
       }
-      const name = import_ts_morph43.Node.isIdentifier(nameNode) ? nameNode.getText() : nameNode.getLiteralValue();
+      const name = import_ts_morph42.Node.isIdentifier(nameNode) ? nameNode.getText() : nameNode.getLiteralValue();
       const initializer = prop.getInitializer();
       if (initializer === void 0) {
         continue;
@@ -10070,7 +9903,7 @@ function extractArg(node, depth) {
     }
     return { kind: "object", fields };
   }
-  if (import_ts_morph43.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph42.Node.isArrayLiteralExpression(node)) {
     const items = node.getElements().map((el) => extractArg(el, depth - 1));
     return { kind: "array", items };
   }
@@ -10078,20 +9911,20 @@ function extractArg(node, depth) {
 }
 function mapCallbackReturn(call) {
   const callee = call.getExpression();
-  if (!import_ts_morph43.Node.isPropertyAccessExpression(callee) || callee.getName() !== "map") {
+  if (!import_ts_morph42.Node.isPropertyAccessExpression(callee) || callee.getName() !== "map") {
     return null;
   }
   const callback = call.getArguments()[0];
-  if (callback === void 0 || !(import_ts_morph43.Node.isArrowFunction(callback) || import_ts_morph43.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph42.Node.isArrowFunction(callback) || import_ts_morph42.Node.isFunctionExpression(callback))) {
     return null;
   }
   const body = callback.getBody();
-  if (!import_ts_morph43.Node.isBlock(body)) {
+  if (!import_ts_morph42.Node.isBlock(body)) {
     return body;
   }
   const statements = body.getStatements();
   const only = statements.length === 1 ? statements[0] : void 0;
-  return only !== void 0 && import_ts_morph43.Node.isReturnStatement(only) ? only.getExpression() ?? null : null;
+  return only !== void 0 && import_ts_morph42.Node.isReturnStatement(only) ? only.getExpression() ?? null : null;
 }
 function collectPreconditions(node, root) {
   return collectAncestorConditionInfosBelow(node, root).map(
@@ -10102,7 +9935,7 @@ function runsOnEveryPath(node, root) {
   let current2 = node;
   while (current2 !== void 0 && current2 !== root) {
     const parent = current2.getParent();
-    if (parent !== void 0 && import_ts_morph43.Node.isTryStatement(parent) && parent.getFinallyBlock() === current2) {
+    if (parent !== void 0 && import_ts_morph42.Node.isTryStatement(parent) && parent.getFinallyBlock() === current2) {
       return true;
     }
     current2 = parent;
@@ -10125,7 +9958,7 @@ function withPreconditions(effect, preconditions) {
   };
 }
 function inlineModuleBinding(ident, depth) {
-  if (!import_ts_morph43.Node.isIdentifier(ident)) {
+  if (!import_ts_morph42.Node.isIdentifier(ident)) {
     return null;
   }
   const symbol = ident.getSymbol();
@@ -10133,7 +9966,7 @@ function inlineModuleBinding(ident, depth) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (!import_ts_morph43.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph42.Node.isVariableDeclaration(decl)) {
       continue;
     }
     if (!isModuleScoped(decl)) {
@@ -10154,10 +9987,10 @@ function inlineModuleBinding(ident, depth) {
 function isModuleScoped(decl) {
   let current2 = decl.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph43.Node.isSourceFile(current2)) {
+    if (import_ts_morph42.Node.isSourceFile(current2)) {
       return true;
     }
-    if (import_ts_morph43.Node.isVariableDeclarationList(current2) || import_ts_morph43.Node.isVariableStatement(current2)) {
+    if (import_ts_morph42.Node.isVariableDeclarationList(current2) || import_ts_morph42.Node.isVariableStatement(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -10171,7 +10004,7 @@ function unwrapCasts(node) {
 function enclosingStatementLine(node) {
   let current2 = node;
   while (current2 !== void 0) {
-    if (import_ts_morph43.Node.isStatement(current2)) {
+    if (import_ts_morph42.Node.isStatement(current2)) {
       return startLineOf(current2);
     }
     current2 = current2.getParent();
@@ -10180,19 +10013,19 @@ function enclosingStatementLine(node) {
 }
 
 // src/terminals/index.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 
 // src/terminals/continuation.ts
-var import_ts_morph45 = require("ts-morph");
+var import_ts_morph44 = require("ts-morph");
 
 // src/terminals/shared.ts
-var import_ts_morph44 = require("ts-morph");
+var import_ts_morph43 = require("ts-morph");
 function parameterPositionOf(identifier, func) {
-  if (!import_ts_morph44.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph43.Node.isIdentifier(identifier)) {
     return null;
   }
   const declaration = identifier.getSymbol()?.getDeclarations()[0];
-  if (declaration === void 0 || !import_ts_morph44.Node.isParameterDeclaration(declaration)) {
+  if (declaration === void 0 || !import_ts_morph43.Node.isParameterDeclaration(declaration)) {
     return null;
   }
   const params = func.getParameters();
@@ -10209,17 +10042,17 @@ function returnPositionOf(value) {
     if (parent === void 0) {
       return null;
     }
-    if (import_ts_morph44.Node.isReturnStatement(parent)) {
+    if (import_ts_morph43.Node.isReturnStatement(parent)) {
       return parent;
     }
-    if (import_ts_morph44.Node.isArrowFunction(parent)) {
+    if (import_ts_morph43.Node.isArrowFunction(parent)) {
       return parent.getBody() === current2 ? current2 : null;
     }
     if (passesValueThrough(parent)) {
       current2 = parent;
       continue;
     }
-    if (import_ts_morph44.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
+    if (import_ts_morph43.Node.isConditionalExpression(parent) && (parent.getWhenTrue() === current2 || parent.getWhenFalse() === current2)) {
       current2 = parent;
       continue;
     }
@@ -10229,7 +10062,7 @@ function returnPositionOf(value) {
 
 // src/terminals/continuation.ts
 function tryMatchParameterCall(node, func, pattern, match) {
-  if (!import_ts_morph45.Node.isCallExpression(node)) {
+  if (!import_ts_morph44.Node.isCallExpression(node)) {
     return null;
   }
   const callee = node.getExpression();
@@ -10252,15 +10085,15 @@ function tryMatchParameterCall(node, func, pattern, match) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph48 = require("ts-morph");
+var import_ts_morph47 = require("ts-morph");
 var import_values5 = require("@suss/values");
 
 // src/shapes/shapes.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph46 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
-var import_ts_morph46 = require("ts-morph");
+var import_ts_morph45 = require("ts-morph");
 
 // src/shapes/definitions.ts
 var current = null;
@@ -10611,7 +10444,7 @@ 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;
+var PRINTED_NAME_FLAGS = import_ts_morph45.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | import_ts_morph45.TypeFormatFlags.UseTypeOfFunction | import_ts_morph45.TypeFormatFlags.NoTruncation | import_ts_morph45.TypeFormatFlags.WriteTypeArgumentsOfSignature;
 function printedTypeName(type, ctx) {
   return withoutImportQualifiers(
     type.getText(ctx.enclosing, PRINTED_NAME_FLAGS)
@@ -10721,60 +10554,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph47.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph46.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph47.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isStringLiteral(unwrapped2) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isStringLiteral(unwrapped2) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph47.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph47.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph47.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph47.SyntaxKind.MinusToken || op === import_ts_morph47.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph46.SyntaxKind.MinusToken || op === import_ts_morph46.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph47.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph46.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph47.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph46.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph47.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph46.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph47.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph47.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph47.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph47.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph47.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph46.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph47.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -10805,7 +10638,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph47.Node.isSpreadElement(el)) {
+    if (import_ts_morph46.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -10824,7 +10657,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph47.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isPropertyAssignment(prop)) {
       const name = propertyName2(prop);
       if (name === null) {
         continue;
@@ -10840,7 +10673,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -10849,7 +10682,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph46.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -10868,7 +10701,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName2(prop) {
   const nameNode = prop.getNameNode();
-  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)) {
+  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)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -10899,15 +10732,15 @@ function unwrapAs(node) {
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph48.Node.isCallExpression(outer)) {
+  if (!import_ts_morph47.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph47.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph48.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph47.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -10917,7 +10750,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph48.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph47.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -10961,10 +10794,10 @@ function statusFromProperty(obj, name, ctx) {
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -10987,7 +10820,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph48.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph47.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -11000,7 +10833,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph48.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -11009,7 +10842,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_morph48.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -11019,8 +10852,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11078,8 +10911,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11134,16 +10967,16 @@ function extractBody(ctx) {
 }
 
 // src/terminals/jsx.ts
-var import_ts_morph49 = require("ts-morph");
+var import_ts_morph48 = require("ts-morph");
 function tryMatchJsxReturn(node, pattern) {
   let expr;
   let source;
-  if (import_ts_morph49.Node.isReturnStatement(node)) {
+  if (import_ts_morph48.Node.isReturnStatement(node)) {
     expr = node.getExpression();
     source = node;
-  } else if (import_ts_morph49.Node.isArrowFunction(node)) {
+  } else if (import_ts_morph48.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph49.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph48.Node.isBlock(body)) {
       expr = body;
       source = body;
     }
@@ -11174,14 +11007,14 @@ function tryMatchJsxReturn(node, pattern) {
   return { node, source, terminal };
 }
 function componentTargetOf(tagNode) {
-  if (!import_ts_morph49.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+  if (!import_ts_morph48.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_morph49.Node.isJsxElement(node)) {
+  if (import_ts_morph48.Node.isJsxElement(node)) {
     const opening = node.getOpeningElement();
     const tag = opening.getTagNameNode().getText();
     const attrs = collectJsxAttributes(opening);
@@ -11195,7 +11028,7 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph49.Node.isJsxSelfClosingElement(node)) {
+  if (import_ts_morph48.Node.isJsxSelfClosingElement(node)) {
     const tag = node.getTagNameNode().getText();
     const attrs = collectJsxAttributes(node);
     const target = componentTargetOf(node.getTagNameNode());
@@ -11207,11 +11040,11 @@ function jsxToRenderNode(node) {
       ...target !== null ? { target } : {}
     };
   }
-  if (import_ts_morph49.Node.isJsxFragment(node)) {
+  if (import_ts_morph48.Node.isJsxFragment(node)) {
     const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
     return { type: "element", tag: "Fragment", children };
   }
-  if (import_ts_morph49.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph48.Node.isParenthesizedExpression(node)) {
     return jsxToRenderNode(node.getExpression());
   }
   return null;
@@ -11219,12 +11052,12 @@ function jsxToRenderNode(node) {
 function collectJsxAttributes(opening) {
   const entries = {};
   for (const attr of opening.getAttributes()) {
-    if (import_ts_morph49.Node.isJsxSpreadAttribute(attr)) {
+    if (import_ts_morph48.Node.isJsxSpreadAttribute(attr)) {
       const exprText = attr.getExpression().getText();
       entries[`...${exprText}`] = exprText;
       continue;
     }
-    if (!import_ts_morph49.Node.isJsxAttribute(attr)) {
+    if (!import_ts_morph48.Node.isJsxAttribute(attr)) {
       continue;
     }
     const name = attr.getNameNode().getText();
@@ -11233,7 +11066,7 @@ function collectJsxAttributes(opening) {
       entries[name] = "";
       continue;
     }
-    if (import_ts_morph49.Node.isJsxExpression(initializer)) {
+    if (import_ts_morph48.Node.isJsxExpression(initializer)) {
       const inner = initializer.getExpression();
       entries[name] = inner !== void 0 ? inner.getText() : "";
       continue;
@@ -11243,30 +11076,30 @@ function collectJsxAttributes(opening) {
   return Object.keys(entries).length > 0 ? entries : null;
 }
 function jsxChildToRenderNode(child) {
-  if (import_ts_morph49.Node.isJsxText(child)) {
+  if (import_ts_morph48.Node.isJsxText(child)) {
     const text = child.getLiteralText().trim();
     if (text.length === 0) {
       return null;
     }
     return { type: "text", value: text };
   }
-  if (import_ts_morph49.Node.isJsxExpression(child)) {
+  if (import_ts_morph48.Node.isJsxExpression(child)) {
     const inner = child.getExpression();
     if (inner === void 0) {
       return null;
     }
     return jsxExpressionToRenderNode(inner);
   }
-  if (import_ts_morph49.Node.isJsxElement(child) || import_ts_morph49.Node.isJsxSelfClosingElement(child) || import_ts_morph49.Node.isJsxFragment(child)) {
+  if (import_ts_morph48.Node.isJsxElement(child) || import_ts_morph48.Node.isJsxSelfClosingElement(child) || import_ts_morph48.Node.isJsxFragment(child)) {
     return jsxToRenderNode(child);
   }
   return null;
 }
 function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph49.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph48.Node.isParenthesizedExpression(expr)) {
     return jsxExpressionToRenderNode(expr.getExpression());
   }
-  if (import_ts_morph49.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph48.Node.isBinaryExpression(expr)) {
     const op = expr.getOperatorToken().getText();
     if (op === "&&") {
       const right = renderAlternative(peelParens(expr.getRight()));
@@ -11280,7 +11113,7 @@ function jsxExpressionToRenderNode(expr) {
       }
     }
   }
-  if (import_ts_morph49.Node.isConditionalExpression(expr)) {
+  if (import_ts_morph48.Node.isConditionalExpression(expr)) {
     const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
     const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
     if (truthy.kind === "jsx") {
@@ -11303,16 +11136,16 @@ function jsxExpressionToRenderNode(expr) {
   return { type: "expression", sourceText: expr.getText() };
 }
 function renderAlternative(node) {
-  if (import_ts_morph49.Node.isNullLiteral(node)) {
+  if (import_ts_morph48.Node.isNullLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph49.Node.isFalseLiteral(node)) {
+  if (import_ts_morph48.Node.isFalseLiteral(node)) {
     return { kind: "noRender" };
   }
-  if (import_ts_morph49.Node.isIdentifier(node) && node.getText() === "undefined") {
+  if (import_ts_morph48.Node.isIdentifier(node) && node.getText() === "undefined") {
     return { kind: "noRender" };
   }
-  if (import_ts_morph49.Node.isJsxElement(node) || import_ts_morph49.Node.isJsxSelfClosingElement(node) || import_ts_morph49.Node.isJsxFragment(node)) {
+  if (import_ts_morph48.Node.isJsxElement(node) || import_ts_morph48.Node.isJsxSelfClosingElement(node) || import_ts_morph48.Node.isJsxFragment(node)) {
     const tree = jsxToRenderNode(node);
     if (tree !== null) {
       return { kind: "jsx", node: tree };
@@ -11322,13 +11155,13 @@ function renderAlternative(node) {
 }
 
 // src/terminals/returns.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph51 = require("ts-morph");
 
 // src/terminals/helperResolution.ts
-var import_ts_morph50 = require("ts-morph");
+var import_ts_morph49 = require("ts-morph");
 function resolveHelperReturn(call, resolveCallee2) {
   const callee = call.getExpression();
-  if (!import_ts_morph50.Node.isIdentifier(callee)) {
+  if (!import_ts_morph49.Node.isIdentifier(callee)) {
     return { kind: "notLocal" };
   }
   const helper = memoizedLocalHelper(callee, resolveCallee2);
@@ -11358,16 +11191,16 @@ function guardsAbove(returnValue) {
   let child = returnValue;
   let current2 = returnValue.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph50.Node.isIfStatement(current2)) {
+    if (import_ts_morph49.Node.isIfStatement(current2)) {
       guards.push({
         condition: current2.getExpression(),
         whenTrue: current2.getThenStatement() === child
       });
     }
-    if (import_ts_morph50.Node.isBlock(current2)) {
+    if (import_ts_morph49.Node.isBlock(current2)) {
       guards.push(...earlyReturnGuardsBefore(current2, child));
     }
-    if (import_ts_morph50.Node.isFunctionDeclaration(current2) || import_ts_morph50.Node.isArrowFunction(current2) || import_ts_morph50.Node.isFunctionExpression(current2)) {
+    if (import_ts_morph49.Node.isFunctionDeclaration(current2) || import_ts_morph49.Node.isArrowFunction(current2) || import_ts_morph49.Node.isFunctionExpression(current2)) {
       break;
     }
     child = current2;
@@ -11376,7 +11209,7 @@ function guardsAbove(returnValue) {
   return guards;
 }
 function earlyReturnGuardsBefore(block, child) {
-  if (!import_ts_morph50.Node.isBlock(block)) {
+  if (!import_ts_morph49.Node.isBlock(block)) {
     return [];
   }
   const guards = [];
@@ -11384,7 +11217,7 @@ function earlyReturnGuardsBefore(block, child) {
     if (statement === child) {
       break;
     }
-    if (!import_ts_morph50.Node.isIfStatement(statement) || statement.getElseStatement()) {
+    if (!import_ts_morph49.Node.isIfStatement(statement) || statement.getElseStatement()) {
       continue;
     }
     if (alwaysReturns(statement.getThenStatement())) {
@@ -11394,10 +11227,10 @@ function earlyReturnGuardsBefore(block, child) {
   return guards;
 }
 function alwaysReturns(statement) {
-  if (import_ts_morph50.Node.isReturnStatement(statement) || import_ts_morph50.Node.isThrowStatement(statement)) {
+  if (import_ts_morph49.Node.isReturnStatement(statement) || import_ts_morph49.Node.isThrowStatement(statement)) {
     return true;
   }
-  if (!import_ts_morph50.Node.isBlock(statement)) {
+  if (!import_ts_morph49.Node.isBlock(statement)) {
     return false;
   }
   const statements = statement.getStatements();
@@ -11415,7 +11248,7 @@ var COMPARISONS = {
   "!=": (a, b) => a !== b
 };
 function evaluateComparison(condition, substitutions) {
-  if (!import_ts_morph50.Node.isBinaryExpression(condition)) {
+  if (!import_ts_morph49.Node.isBinaryExpression(condition)) {
     return null;
   }
   const left = numberFor(condition.getLeft(), substitutions);
@@ -11427,8 +11260,8 @@ function evaluateComparison(condition, substitutions) {
   return compare === void 0 ? null : compare(left, right);
 }
 function numberFor(node, substitutions) {
-  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;
+  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;
 }
 var helperBySymbol = /* @__PURE__ */ new WeakMap();
 function memoizedLocalHelper(callee, resolveCallee2) {
@@ -11515,12 +11348,12 @@ function declarationsFor(callee, resolveCallee2) {
   return (aliased ?? symbol).getDeclarations();
 }
 function asFunctionLike(declaration) {
-  if (import_ts_morph50.Node.isFunctionDeclaration(declaration) || import_ts_morph50.Node.isArrowFunction(declaration) || import_ts_morph50.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph49.Node.isFunctionDeclaration(declaration) || import_ts_morph49.Node.isArrowFunction(declaration) || import_ts_morph49.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (import_ts_morph50.Node.isVariableDeclaration(declaration)) {
+  if (import_ts_morph49.Node.isVariableDeclaration(declaration)) {
     const initializer = declaration.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph50.Node.isArrowFunction(initializer) || import_ts_morph50.Node.isFunctionExpression(initializer))) {
+    if (initializer !== void 0 && (import_ts_morph49.Node.isArrowFunction(initializer) || import_ts_morph49.Node.isFunctionExpression(initializer))) {
       return initializer;
     }
   }
@@ -11531,13 +11364,13 @@ function returnedObjects(fn) {
   if (body === void 0) {
     return [];
   }
-  if (!import_ts_morph50.Node.isBlock(body)) {
+  if (!import_ts_morph49.Node.isBlock(body)) {
     const expression = peelParens(body);
-    return import_ts_morph50.Node.isObjectLiteralExpression(expression) ? [expression] : [];
+    return import_ts_morph49.Node.isObjectLiteralExpression(expression) ? [expression] : [];
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    import_ts_morph50.SyntaxKind.ReturnStatement
+    import_ts_morph49.SyntaxKind.ReturnStatement
   )) {
     if (enclosingFunctionOf(statement) !== body) {
       continue;
@@ -11547,7 +11380,7 @@ function returnedObjects(fn) {
       continue;
     }
     const unwrapped2 = peelParens(expression);
-    if (import_ts_morph50.Node.isObjectLiteralExpression(unwrapped2)) {
+    if (import_ts_morph49.Node.isObjectLiteralExpression(unwrapped2)) {
       found.push(unwrapped2);
     }
   }
@@ -11556,7 +11389,7 @@ function returnedObjects(fn) {
 function enclosingFunctionOf(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    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)) {
+    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)) {
       return current2.getBody();
     }
     current2 = current2.getParent();
@@ -11575,7 +11408,7 @@ function bindArguments(callArgs, params) {
 }
 
 // src/terminals/statusBranches.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph50 = require("ts-morph");
 var import_values6 = require("@suss/values");
 function statusChoicesOf(argument, resolution) {
   const chosen = asConditional(argument);
@@ -11599,10 +11432,10 @@ function asConditional(node) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph51.Node.isIdentifier(node)) {
+  if (!import_ts_morph50.Node.isIdentifier(node)) {
     return null;
   }
-  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph51.Node.isVariableDeclaration);
+  const declaration = node.getSymbol()?.getDeclarations().find(import_ts_morph50.Node.isVariableDeclaration);
   if (declaration === void 0) {
     return null;
   }
@@ -11613,7 +11446,7 @@ function asConditional(node) {
   const only = written.values[0];
   return only === void 0 ? null : toConditional(only);
 }
-var toConditional = (node) => import_ts_morph51.Node.isConditionalExpression(node) ? node : null;
+var toConditional = (node) => import_ts_morph50.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;
@@ -11630,7 +11463,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_morph52.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     if (callee.getName() !== expectedMethod) {
@@ -11646,7 +11479,7 @@ function unwrapMethodChain(call, match, func) {
         return null;
       }
     } else {
-      if (!import_ts_morph52.Node.isCallExpression(subject)) {
+      if (!import_ts_morph51.Node.isCallExpression(subject)) {
         return null;
       }
       current2 = subject;
@@ -11656,9 +11489,9 @@ function unwrapMethodChain(call, match, func) {
 }
 function withoutPassThroughCalls(subject, passThrough) {
   let current2 = subject;
-  while (import_ts_morph52.Node.isCallExpression(current2)) {
+  while (import_ts_morph51.Node.isCallExpression(current2)) {
     const callee = current2.getExpression();
-    if (!import_ts_morph52.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
+    if (!import_ts_morph51.Node.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
       break;
     }
     current2 = callee.getExpression();
@@ -11670,12 +11503,12 @@ function returnedValueOf(returnStatement) {
   return written === void 0 ? null : unwrapValue(written);
 }
 function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
-  if (import_ts_morph52.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph51.Node.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
       return [];
     }
-    if (import_ts_morph52.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
+    if (import_ts_morph51.Node.isReturnStatement(source) && returnedValueOf(source) === node) {
       return [];
     }
     const terminal = terminalFromReturnedObject(
@@ -11688,14 +11521,14 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
-  if (!import_ts_morph52.Node.isReturnStatement(node)) {
+  if (!import_ts_morph51.Node.isReturnStatement(node)) {
     return [];
   }
   const returned = returnedValueOf(node);
   if (returned === null) {
     return [];
   }
-  if (import_ts_morph52.Node.isObjectLiteralExpression(returned)) {
+  if (import_ts_morph51.Node.isObjectLiteralExpression(returned)) {
     const terminal = terminalFromReturnedObject(
       returned,
       node,
@@ -11706,7 +11539,7 @@ function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
     );
     return terminal === null ? [] : [terminal];
   }
-  if (!import_ts_morph52.Node.isCallExpression(returned)) {
+  if (!import_ts_morph51.Node.isCallExpression(returned)) {
     return [];
   }
   const resolved = resolveHelperReturn(returned, resolveCallee2);
@@ -11743,7 +11576,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_morph52.Node.isPropertyAssignment(prop) || import_ts_morph52.Node.isShorthandPropertyAssignment(prop)) {
+      if (import_ts_morph51.Node.isPropertyAssignment(prop) || import_ts_morph51.Node.isShorthandPropertyAssignment(prop)) {
         presentNames.add(prop.getName());
       }
     }
@@ -11769,7 +11602,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_morph52.Node.isReturnStatement(anchor) ? { source: anchor } : {},
+    ...import_ts_morph51.Node.isReturnStatement(anchor) ? { source: anchor } : {},
     terminal: {
       kind: pattern.kind,
       statusCode,
@@ -11788,7 +11621,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
   };
 }
 function tryMatchParameterMethodCall(node, func, pattern, match, resolution) {
-  if (!import_ts_morph52.Node.isCallExpression(node)) {
+  if (!import_ts_morph51.Node.isCallExpression(node)) {
     return [];
   }
   const result = unwrapMethodChain(node, match, func);
@@ -11848,7 +11681,7 @@ function statusArgument(calls, extraction) {
 }
 function returnCoveredByParameterMethodCall(expr, func, patterns) {
   const current2 = unwrapValue(expr);
-  if (!import_ts_morph52.Node.isCallExpression(current2)) {
+  if (!import_ts_morph51.Node.isCallExpression(current2)) {
     return false;
   }
   for (const pattern of patterns) {
@@ -11864,7 +11697,7 @@ function returnCoveredByParameterMethodCall(expr, func, patterns) {
 }
 function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   const match = pattern.match.type === "returnStatement" ? pattern.match : null;
-  if (import_ts_morph52.Node.isReturnStatement(node)) {
+  if (import_ts_morph51.Node.isReturnStatement(node)) {
     const expr = node.getExpression();
     if (match?.excludeCallReturns === true) {
       if (expr === void 0) {
@@ -11883,9 +11716,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
     }
     return buildReturnTerminal(node, pattern, body);
   }
-  if (import_ts_morph52.Node.isArrowFunction(node)) {
+  if (import_ts_morph51.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (body === void 0 || import_ts_morph52.Node.isBlock(body)) {
+    if (body === void 0 || import_ts_morph51.Node.isBlock(body)) {
       return null;
     }
     const shape = extractShape(body);
@@ -11943,20 +11776,20 @@ function unresolvedTerminal(kind, node) {
   };
 }
 function calleeSubject(callee) {
-  if (import_ts_morph52.Node.isIdentifier(callee)) {
+  if (import_ts_morph51.Node.isIdentifier(callee)) {
     return callee;
   }
-  if (import_ts_morph52.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
     const subject = callee.getExpression();
-    return import_ts_morph52.Node.isIdentifier(subject) ? subject : null;
+    return import_ts_morph51.Node.isIdentifier(subject) ? subject : null;
   }
   return null;
 }
 function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom) {
-  if (!import_ts_morph52.Node.isCallExpression(node) && !import_ts_morph52.Node.isNewExpression(node)) {
+  if (!import_ts_morph51.Node.isCallExpression(node) && !import_ts_morph51.Node.isNewExpression(node)) {
     return null;
   }
-  if (import_ts_morph52.Node.isNewExpression(node) && returnPositionOf(node) === null) {
+  if (import_ts_morph51.Node.isNewExpression(node) && returnPositionOf(node) === null) {
     return null;
   }
   const callee = node.getExpression();
@@ -11995,9 +11828,9 @@ function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom)
 }
 
 // src/terminals/throws.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 function tryMatchThrowExpression(node, pattern, match, resolution) {
-  if (!import_ts_morph53.Node.isThrowStatement(node)) {
+  if (!import_ts_morph52.Node.isThrowStatement(node)) {
     return null;
   }
   const thrownExpr = node.getExpression();
@@ -12039,17 +11872,17 @@ function extractThrowMessage(callArgs) {
     return null;
   }
   for (const arg of callArgs) {
-    if (import_ts_morph53.Node.isStringLiteral(arg) || import_ts_morph53.Node.isNoSubstitutionTemplateLiteral(arg)) {
+    if (import_ts_morph52.Node.isStringLiteral(arg) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(arg)) {
       return arg.getLiteralValue();
     }
-    if (import_ts_morph53.Node.isTemplateExpression(arg)) {
+    if (import_ts_morph52.Node.isTemplateExpression(arg)) {
       return arg.getText();
     }
   }
   return null;
 }
 function classifyThrownExpression(thrown, constructorPattern) {
-  if (import_ts_morph53.Node.isCallExpression(thrown) || import_ts_morph53.Node.isNewExpression(thrown)) {
+  if (import_ts_morph52.Node.isCallExpression(thrown) || import_ts_morph52.Node.isNewExpression(thrown)) {
     const calleeText = thrown.getExpression().getText();
     if (constructorPattern !== void 0 && !calleeText.startsWith(constructorPattern)) {
       return null;
@@ -12136,9 +11969,9 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, origi
       }
     }
   });
-  if (results.length === 0 && import_ts_morph54.Node.isArrowFunction(func)) {
+  if (results.length === 0 && import_ts_morph53.Node.isArrowFunction(func)) {
     const body = func.getBody();
-    if (body !== void 0 && !import_ts_morph54.Node.isBlock(body)) {
+    if (body !== void 0 && !import_ts_morph53.Node.isBlock(body)) {
       for (const pattern of patterns) {
         let found = null;
         if (pattern.match.type === "parameterMethodCall") {
@@ -12173,7 +12006,7 @@ function functionMayFallThrough(func) {
   if (body === void 0) {
     return false;
   }
-  if (!import_ts_morph54.Node.isBlock(body)) {
+  if (!import_ts_morph53.Node.isBlock(body)) {
     return false;
   }
   const statements = body.getStatements();
@@ -12181,7 +12014,7 @@ function functionMayFallThrough(func) {
     return true;
   }
   const last = statements[statements.length - 1];
-  if (import_ts_morph54.Node.isReturnStatement(last) || import_ts_morph54.Node.isThrowStatement(last)) {
+  if (import_ts_morph53.Node.isReturnStatement(last) || import_ts_morph53.Node.isThrowStatement(last)) {
     return false;
   }
   return true;
@@ -12229,7 +12062,7 @@ function writesTerminal(call, terminalNodes) {
   }
 }
 function isReceiverOf(node, parent) {
-  return (import_ts_morph55.Node.isPropertyAccessExpression(parent) || import_ts_morph55.Node.isElementAccessExpression(parent) || import_ts_morph55.Node.isCallExpression(parent)) && parent.getExpression() === node;
+  return (import_ts_morph54.Node.isPropertyAccessExpression(parent) || import_ts_morph54.Node.isElementAccessExpression(parent) || import_ts_morph54.Node.isCallExpression(parent)) && parent.getExpression() === node;
 }
 var isDefaultConditionList = (conditions) => conditions.length === 0 || conditions.every(
   (c) => c.source === "earlyReturn" || c.source === "earlyThrow"
@@ -12239,7 +12072,7 @@ function bodyContentOf(func) {
   if (body === void 0) {
     return "absent";
   }
-  if (!import_ts_morph55.Node.isBlock(body)) {
+  if (!import_ts_morph54.Node.isBlock(body)) {
     return "statements";
   }
   return body.getStatements().length === 0 ? "empty" : "statements";
@@ -12255,7 +12088,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       claimed.add(source);
     }
   }
-  if (import_ts_morph55.Node.isArrowFunction(func) && import_ts_morph55.Node.isExpression(body)) {
+  if (import_ts_morph54.Node.isArrowFunction(func) && import_ts_morph54.Node.isExpression(body)) {
     return claimed.has(body) ? 0 : 1;
   }
   let unmatched = 0;
@@ -12268,7 +12101,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph55.Node.isReturnStatement(node)) {
+    if (!import_ts_morph54.Node.isReturnStatement(node)) {
       return;
     }
     if (node.getExpression() === void 0) {
@@ -12421,7 +12254,7 @@ function accountFor(site, terminalNodes, branches) {
 }
 
 // src/bootstrap/sourceFileLookup.ts
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 function createSourceFileLookup(project) {
   const all = project.getSourceFiles();
   const byAbs = /* @__PURE__ */ new Map();
@@ -12483,7 +12316,7 @@ function spanKey(span) {
 function indexFunctions(sf) {
   const index = /* @__PURE__ */ new Map();
   sf.forEachDescendant((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)) {
+    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)) {
       return;
     }
     const bySpan = spanKey({ start: node.getStart(), end: node.getEnd() });
@@ -12497,13 +12330,13 @@ function indexFunctions(sf) {
 }
 
 // src/contract.ts
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph56 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 function extractDeclaredBody(node) {
   if (node === void 0) {
     return null;
   }
-  if (!import_ts_morph57.Node.isCallExpression(node)) {
+  if (!import_ts_morph56.Node.isCallExpression(node)) {
     return null;
   }
   const typeArgs = node.getTypeArguments();
@@ -12517,10 +12350,10 @@ function resolveHandlerPropNode(func) {
   if (parent === void 0) {
     return null;
   }
-  if (import_ts_morph57.Node.isPropertyAssignment(parent)) {
+  if (import_ts_morph56.Node.isPropertyAssignment(parent)) {
     return parent;
   }
-  if (import_ts_morph57.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph56.Node.isMethodDeclaration(func)) {
     return func;
   }
   return null;
@@ -12532,11 +12365,11 @@ function findRouterCall(unit) {
     return null;
   }
   const handlersObj = propNode.getParent();
-  if (handlersObj === void 0 || !import_ts_morph57.Node.isObjectLiteralExpression(handlersObj)) {
+  if (handlersObj === void 0 || !import_ts_morph56.Node.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
   const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !import_ts_morph57.Node.isCallExpression(routerCall)) {
+  if (routerCall === void 0 || !import_ts_morph56.Node.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -12549,17 +12382,17 @@ function findRouterCall(unit) {
   };
 }
 function resolveContractObject(contractArg, resolution) {
-  if (import_ts_morph57.Node.isObjectLiteralExpression(contractArg)) {
+  if (import_ts_morph56.Node.isObjectLiteralExpression(contractArg)) {
     return contractArg;
   }
-  if (import_ts_morph57.Node.isPropertyAccessExpression(contractArg)) {
+  if (import_ts_morph56.Node.isPropertyAccessExpression(contractArg)) {
     const base = resolveContractObject(contractArg.getExpression(), resolution);
-    if (base === null || !import_ts_morph57.Node.isObjectLiteralExpression(base)) {
+    if (base === null || !import_ts_morph56.Node.isObjectLiteralExpression(base)) {
       return null;
     }
     const propName = contractArg.getName();
     for (const prop of base.getProperties()) {
-      if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
         continue;
       }
       if (prop.getName() !== propName) {
@@ -12569,20 +12402,20 @@ function resolveContractObject(contractArg, resolution) {
       if (value === void 0) {
         return null;
       }
-      if (import_ts_morph57.Node.isObjectLiteralExpression(value)) {
+      if (import_ts_morph56.Node.isObjectLiteralExpression(value)) {
         return value;
       }
-      if (import_ts_morph57.Node.isIdentifier(value) || import_ts_morph57.Node.isPropertyAccessExpression(value)) {
+      if (import_ts_morph56.Node.isIdentifier(value) || import_ts_morph56.Node.isPropertyAccessExpression(value)) {
         return resolveContractObject(value, resolution);
       }
-      if (import_ts_morph57.Node.isCallExpression(value)) {
+      if (import_ts_morph56.Node.isCallExpression(value)) {
         return unwrapContractInit(value);
       }
       return null;
     }
     return null;
   }
-  if (!import_ts_morph57.Node.isIdentifier(contractArg)) {
+  if (!import_ts_morph56.Node.isIdentifier(contractArg)) {
     return null;
   }
   const symbol = contractArg.getSymbol();
@@ -12594,7 +12427,7 @@ function resolveContractObject(contractArg, resolution) {
     return null;
   }
   const decl = decls[0];
-  if (import_ts_morph57.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph56.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sourceFile = importDecl.getModuleSpecifierSourceFile();
     if (sourceFile !== void 0 && resolution !== void 0) {
@@ -12603,14 +12436,14 @@ function resolveContractObject(contractArg, resolution) {
       );
       if (exported !== void 0 && exported.length > 0) {
         const exportedDecl = exported[0];
-        if (import_ts_morph57.Node.isVariableDeclaration(exportedDecl)) {
+        if (import_ts_morph56.Node.isVariableDeclaration(exportedDecl)) {
           return unwrapContractInit(exportedDecl.getInitializer());
         }
       }
     }
     return null;
   }
-  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
     return unwrapContractInit(decl.getInitializer());
   }
   return null;
@@ -12620,39 +12453,39 @@ function unwrapContractInit(init) {
     return null;
   }
   const node = peelSyntax(init);
-  if (import_ts_morph57.Node.isCallExpression(node)) {
+  if (import_ts_morph56.Node.isCallExpression(node)) {
     const args = node.getArguments();
-    if (args.length > 0 && import_ts_morph57.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length > 0 && import_ts_morph56.Node.isObjectLiteralExpression(args[0])) {
       return args[0];
     }
     return null;
   }
-  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
     return node;
   }
   return null;
 }
 function extractEndpointContract(endpointNode, pattern, framework, resolution) {
-  if (!import_ts_morph57.Node.isObjectLiteralExpression(endpointNode)) {
+  if (!import_ts_morph56.Node.isObjectLiteralExpression(endpointNode)) {
     return null;
   }
   const responses = [];
   let method;
   let path15;
   for (const prop of endpointNode.getProperties()) {
-    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const propName = prop.getName();
     if (propName === pattern.methodProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
         method = val.getLiteralValue();
       }
     }
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph57.Node.isStringLiteral(val)) {
+      if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
         path15 = val.getLiteralValue();
       }
     }
@@ -12661,7 +12494,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_morph57.Node.isPropertyAssignment(respProp)) {
+          if (!import_ts_morph56.Node.isPropertyAssignment(respProp)) {
             continue;
           }
           const statusStr = respProp.getName();
@@ -12711,11 +12544,11 @@ function readContract(unit, pattern, framework, resolution) {
     return null;
   }
   const contractObj = resolveContractObject(routerInfo.contractArg, resolution);
-  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== routerInfo.handlerName) {
@@ -12740,7 +12573,7 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   const call = func.getParent();
-  if (call === void 0 || !import_ts_morph57.Node.isCallExpression(call)) {
+  if (call === void 0 || !import_ts_morph56.Node.isCallExpression(call)) {
     return null;
   }
   const args = call.getArguments();
@@ -12752,24 +12585,24 @@ function endpointFromRegistrationArgument(unit, position, resolution) {
     return null;
   }
   let node = arg;
-  while (import_ts_morph57.Node.isAsExpression(node)) {
+  while (import_ts_morph56.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
-  if (import_ts_morph57.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph56.Node.isObjectLiteralExpression(node)) {
     return node;
   }
-  if (import_ts_morph57.Node.isCallExpression(node)) {
+  if (import_ts_morph56.Node.isCallExpression(node)) {
     return unwrapContractInit(node);
   }
   return resolveContractObject(node, resolution);
 }
 function readContractForClientCall(callExpression, methodName, pattern, framework, resolution) {
-  const callee = import_ts_morph57.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
-  if (callee === null || !import_ts_morph57.Node.isPropertyAccessExpression(callee)) {
+  const callee = import_ts_morph56.Node.isCallExpression(callExpression) ? callExpression.getExpression() : null;
+  if (callee === null || !import_ts_morph56.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   const clientIdentifier = callee.getExpression();
-  if (!import_ts_morph57.Node.isIdentifier(clientIdentifier)) {
+  if (!import_ts_morph56.Node.isIdentifier(clientIdentifier)) {
     return null;
   }
   const symbol = clientIdentifier.getSymbol();
@@ -12781,11 +12614,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const decl = decls[0];
-  if (!import_ts_morph57.Node.isVariableDeclaration(decl)) {
+  if (!import_ts_morph56.Node.isVariableDeclaration(decl)) {
     return null;
   }
   const init = decl.getInitializer();
-  if (init === void 0 || !import_ts_morph57.Node.isCallExpression(init)) {
+  if (init === void 0 || !import_ts_morph56.Node.isCallExpression(init)) {
     return null;
   }
   const args = init.getArguments();
@@ -12793,11 +12626,11 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     return null;
   }
   const contractObj = resolveContractObject(args[0], resolution);
-  if (contractObj === null || !import_ts_morph57.Node.isObjectLiteralExpression(contractObj)) {
+  if (contractObj === null || !import_ts_morph56.Node.isObjectLiteralExpression(contractObj)) {
     return null;
   }
   for (const prop of contractObj.getProperties()) {
-    if (!import_ts_morph57.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
       continue;
     }
     if (prop.getName() !== methodName) {
@@ -12817,6 +12650,154 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
   return null;
 }
 
+// src/diagnostics.ts
+var import_node_path7 = __toESM(require("path"), 1);
+var import_ts_morph57 = require("ts-morph");
+var import_extractor6 = require("@suss/extractor");
+var DEFAULT_RESOLUTION = {
+  moduleResolution: import_ts_morph57.ts.ModuleResolutionKind.Bundler,
+  target: import_ts_morph57.ts.ScriptTarget.ESNext,
+  module: import_ts_morph57.ts.ModuleKind.ESNext
+};
+function resolutionContext(args) {
+  if (args.tsConfigFilePath !== void 0) {
+    const configFile = import_ts_morph57.ts.readConfigFile(
+      args.tsConfigFilePath,
+      import_ts_morph57.ts.sys.readFile
+    );
+    if (configFile.error !== void 0) {
+      return null;
+    }
+    const dir = import_node_path7.default.dirname(args.tsConfigFilePath);
+    const parsed = import_ts_morph57.ts.parseJsonConfigFileContent(
+      configFile.config,
+      import_ts_morph57.ts.sys,
+      dir,
+      /*existingOptions*/
+      void 0,
+      args.tsConfigFilePath
+    );
+    return {
+      containingFile: import_node_path7.default.join(dir, "index.ts"),
+      options: parsed.options
+    };
+  }
+  if (args.projectRoot === void 0 || !import_node_path7.default.isAbsolute(args.projectRoot)) {
+    return null;
+  }
+  return {
+    containingFile: import_node_path7.default.join(args.projectRoot, "index.ts"),
+    options: DEFAULT_RESOLUTION
+  };
+}
+function unresolvedGatesFor(gates, args) {
+  if (gates.length === 0) {
+    return [];
+  }
+  const context = resolutionContext(args);
+  if (context === null) {
+    return [];
+  }
+  const unresolved = [];
+  for (const gate of gates) {
+    const resolved = import_ts_morph57.ts.resolveModuleName(
+      gate,
+      context.containingFile,
+      context.options,
+      import_ts_morph57.ts.sys
+    );
+    if (resolved.resolvedModule === void 0) {
+      unresolved.push(gate);
+    }
+  }
+  return unresolved;
+}
+function helpersWithNoCall(patterns, matched, projectRoot) {
+  const missing = [];
+  for (const pattern of patterns) {
+    if (pattern.match.type !== "registrationTemplate" || matched.has(pattern.match.helperName)) {
+      continue;
+    }
+    const from = pattern.match.importModule;
+    missing.push(
+      from === void 0 ? pattern.match.helperName : `${pattern.match.helperName} from ${shortModule(from, projectRoot)}`
+    );
+  }
+  return missing;
+}
+function shortModule(module2, projectRoot) {
+  if (projectRoot === void 0 || !import_node_path7.default.isAbsolute(module2)) {
+    return module2;
+  }
+  return import_node_path7.default.relative(projectRoot, module2);
+}
+function buildExtractionReport(args) {
+  const bySummary = (0, import_extractor6.summaryCountsByPack)(args.summaries);
+  const packFunnels = args.packs.map((pack) => {
+    const gates = packIsUngated(pack) ? [] : collectPackGates(pack);
+    const tally = args.tallies.get(pack.name) ?? (0, import_extractor6.emptyTally)();
+    const counted = bySummary.get(pack.name) ?? {
+      bound: 0,
+      providers: 0,
+      withBehavior: 0
+    };
+    return {
+      pack: pack.name,
+      version: pack.version ?? null,
+      discovers: pack.discovery.length > 0 || pack.discoverUnits !== void 0,
+      recognizes: (pack.invocationRecognizers?.length ?? 0) > 0 || (pack.accessRecognizers?.length ?? 0) > 0,
+      gates,
+      unresolvedGates: unresolvedGatesFor(gates, {
+        tsConfigFilePath: args.tsConfigFilePath,
+        projectRoot: args.projectRoot
+      }),
+      candidateFiles: tally.candidateFiles,
+      unitsDiscovered: tally.unitsDiscovered,
+      unitsInGatedFiles: tally.unitsInGatedFiles,
+      effectsRecognized: tally.effectsRecognized,
+      unitsClaimed: tally.unitsClaimed,
+      summariesProduced: tally.summariesProduced,
+      failures: tally.failures,
+      helpersUnmatched: helpersWithNoCall(
+        [...pack.discovery, ...args.contributedPatterns?.(pack.name) ?? []],
+        tally.helpersMatched,
+        args.projectRoot
+      ),
+      summariesBound: counted.bound,
+      providerSummaries: counted.providers,
+      summariesWithBehavior: counted.withBehavior,
+      declarations: pack.declarations ?? null
+    };
+  });
+  return {
+    filesInProject: args.filesInProject,
+    filesWalked: args.filesWalked,
+    packs: packFunnels,
+    summaries: args.summaries.length,
+    filesWithUnreadableExports: [...args.filesWithUnreadableExports ?? []],
+    reassignedNamesUnstated: args.reassignedNamesUnstated ?? 0,
+    emptyStage: args.summaries.length === 0 ? firstEmptyStage(packFunnels, args) : null
+  };
+}
+function firstEmptyStage(packs, args) {
+  if (args.filesInProject === 0) {
+    return "tsconfig";
+  }
+  const gateFailed = packs.some(
+    (p) => p.unresolvedGates.length > 0 && p.candidateFiles > 0
+  );
+  if (gateFailed) {
+    return "gateResolution";
+  }
+  if (args.filesWalked === 0 || packs.every((p) => p.candidateFiles === 0)) {
+    return "candidateFiles";
+  }
+  if (packs.every((p) => p.unitsDiscovered === 0)) {
+    return "discovery";
+  }
+  return "assembly";
+}
+
 // src/discovery/filenameRoute.ts
 function routePathFromFile(filePath, convention) {
   const belowRoot = segmentsBelowRoot(filePath, convention.root);
@@ -14143,7 +14124,7 @@ function scalarOrRef(node) {
 }
 
 // src/moduleInit.ts
-var import_extractor6 = require("@suss/extractor");
+var import_extractor7 = require("@suss/extractor");
 function moduleInitName(sourceFile) {
   return sourceFile.getBaseName();
 }
@@ -14151,8 +14132,8 @@ function moduleInitSummary(sourceFile, effects, options) {
   if (effects.length === 0) {
     return null;
   }
-  return (0, import_extractor6.assembleSummary)(
-    (0, import_extractor6.moduleInitStructure)({
+  return (0, import_extractor7.assembleSummary)(
+    (0, import_extractor7.moduleInitStructure)({
       name: moduleInitName(sourceFile),
       file: sourceFile.getFilePath(),
       range: { start: 0, end: sourceFile.getEnd() },
@@ -14309,7 +14290,7 @@ function deriveBoundaryEffects(summaries, facts) {
 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");
+var import_extractor8 = require("@suss/extractor");
 var GENERIC_TERMINALS = [
   { kind: "return", match: { type: "returnStatement" }, extraction: {} },
   { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
@@ -14522,7 +14503,7 @@ function extractReachableSummary(candidate, options, recognizers) {
     transport: "in-process",
     recognition: "reachable"
   });
-  return (0, import_extractor7.assembleSummary)(raw, options);
+  return (0, import_extractor8.assembleSummary)(raw, options);
 }
 var REACHABLE_RULES = [
   (0, import_datalog4.rule)("reachable", [(0, import_datalog4.variable)("f")], [(0, import_datalog4.lit)("entry", (0, import_datalog4.variable)("f"))]),
@@ -15586,14 +15567,14 @@ function idFor(workspace, file, summary) {
 }
 
 // src/timing.ts
-var import_extractor8 = require("@suss/extractor");
+var import_extractor9 = require("@suss/extractor");
 
 // src/version.ts
-var import_extractor9 = require("@suss/extractor");
 var import_extractor10 = require("@suss/extractor");
+var import_extractor11 = require("@suss/extractor");
 var import_meta = {};
 var ADAPTER_VERSION = "0.2.1";
-var stamp = (0, import_extractor9.createAdapterStamp)({
+var stamp = (0, import_extractor10.createAdapterStamp)({
   moduleUrl: import_meta.url,
   version: ADAPTER_VERSION
 });
@@ -15761,7 +15742,7 @@ function workspaceExpansionStamp(frameworks) {
   const paths = frameworks.flatMap((pack) => pack.discovery).flatMap(
     (pattern) => pattern.match.type === "packageExports" && pattern.match.packageJsonPath !== void 0 ? [pattern.match.packageJsonPath] : []
   );
-  return (0, import_extractor10.projectFileStamp)(paths);
+  return (0, import_extractor11.projectFileStamp)(paths);
 }
 function expandWorkspacePatterns(frameworks, anchor) {
   const marked = frameworks.some(
@@ -16407,7 +16388,7 @@ function computeSubUnitBarriers(unit, packs, ctx, tallies, file) {
       }
     } catch (err) {
       process.stderr.write(
-        (0, import_extractor3.recordPackFailure)(tallies?.get(pack.name), {
+        (0, import_extractor6.recordPackFailure)(tallies?.get(pack.name), {
           pack: pack.name,
           hook: "subUnits",
           file,
@@ -16469,7 +16450,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         }
       } catch (err) {
         process.stderr.write(
-          (0, import_extractor3.recordPackFailure)(tally, {
+          (0, import_extractor6.recordPackFailure)(tally, {
             pack: pack.name,
             hook: "discoverUnits",
             file: sourceFile.getFilePath(),
@@ -16679,7 +16660,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
           });
         }
       }
-      const summary = (0, import_extractor11.assembleSummary)(raw, options);
+      const summary = (0, import_extractor12.assembleSummary)(raw, options);
       if (options?.gapHandling !== "silent") {
         for (const stop of unfollowedStopsOf(unit, wrappers)) {
           summary.gaps.push((0, import_behavioral_ir2.unfollowedCallGap)(stop));
@@ -17022,7 +17003,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path15, options) {
     path: path15,
     recognition: wrapperBinding?.recognition ?? "unknown"
   });
-  const summary = (0, import_extractor11.assembleSummary)(raw, options);
+  const summary = (0, import_extractor12.assembleSummary)(raw, options);
   summary.metadata = {
     ...summary.metadata ?? {},
     derivedFromWrapper: {
@@ -17034,7 +17015,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path15, options) {
   return summary;
 }
 function named(summaries, workspace, runRoot) {
-  const projectRoot = runRoot ?? commonDirectoryOf(summaries.map((s) => s.location.file));
+  const projectRoot = runRoot ?? (0, import_extractor12.commonDirectoryOf)(summaries.map((s) => s.location.file));
   nameSummaries(summaries, {
     workspace: workspace ?? workspaceNameFor(projectRoot),
     projectRoot
@@ -17092,7 +17073,7 @@ function createTypeScriptAdapter(suppliedConfig) {
   const cacheDir = declineWhenRunFromSource(
     config.cacheDir === null ? null : config.cacheDir ?? (config.tsConfigFilePath !== void 0 ? import_node_path11.default.join(import_node_path11.default.dirname(config.tsConfigFilePath), ".suss", "cache") : null)
   );
-  const cache = (0, import_extractor11.createCacheLayer)(cacheDir);
+  const cache = (0, import_extractor12.createCacheLayer)(cacheDir);
   const packsDigest = `${computeAdapterPacksDigest(
     config.frameworks.map(
       (p) => p.version !== void 0 ? { name: p.name, version: p.version } : { name: p.name }
@@ -17130,8 +17111,8 @@ function createTypeScriptAdapter(suppliedConfig) {
       return named(summaries, config.workspace, runRoot);
     },
     async extractAll() {
-      const timer = (0, import_extractor8.createTimer)();
-      const tallies = (0, import_extractor3.createPackTallies)(config.frameworks);
+      const timer = (0, import_extractor9.createTimer)();
+      const tallies = (0, import_extractor6.createPackTallies)(config.frameworks);
       forgetUnreadableExportFiles();
       forgetReassignedNamesUnstated();
       const lazyEligible = !lazyBootstrapped && config.tsConfigFilePath !== void 0 && config.project === void 0;
@@ -17144,7 +17125,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       let cacheFiles = null;
       const adapterPacksDigest = cacheDir === null ? packsDigest : timer.time("cache.digest", () => {
         cacheFiles = tsconfigFileList ?? project.getSourceFiles().map((sf) => sf.getFilePath());
-        return (0, import_extractor11.runDigest)(packsDigest, config.frameworks, cacheFiles);
+        return (0, import_extractor12.runDigest)(packsDigest, config.frameworks, cacheFiles);
       });
       const cacheInput = {
         // Empty when cacheDir is null: a no-op cache layer never reads
@@ -17395,7 +17376,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       }
       timer.time(
         "stampModuleImports",
-        () => (0, import_extractor11.stampModuleImports)(enriched, (file) => {
+        () => (0, import_extractor12.stampModuleImports)(enriched, (file) => {
           const imports = internalImportsOf(project, file);
           return imports.length === 0 ? void 0 : imports;
         })
@@ -17457,7 +17438,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       });
       const composed = timer.time(
         "composeWrappers",
-        () => (0, import_extractor11.composeWrappers)(enriched, config.extractorOptions ?? {})
+        () => (0, import_extractor12.composeWrappers)(enriched, config.extractorOptions ?? {})
       );
       if (config.onTiming !== void 0) {
         config.onTiming(timer.report());
@@ -17471,7 +17452,7 @@ function createTypeScriptAdapter(suppliedConfig) {
             filesWalked: walkList.length,
             summaries: composed,
             tsConfigFilePath: config.tsConfigFilePath,
-            projectRoot: commonDirectoryOf(
+            projectRoot: (0, import_extractor12.commonDirectoryOf)(
               sourceFiles.map((f) => f.getFilePath())
             ),
             filesWithUnreadableExports: unreadableExportFiles(),
@@ -17483,7 +17464,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       return named(
         composed,
         config.workspace,
-        runRoot ?? commonDirectoryOf(sourceFiles.map((f) => f.getFilePath()))
+        runRoot ?? (0, import_extractor12.commonDirectoryOf)(sourceFiles.map((f) => f.getFilePath()))
       );
     }
   };
@@ -17782,7 +17763,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
   if (parent.identity.boundaryBinding !== null) {
     raw.boundaryBinding = parent.identity.boundaryBinding;
   }
-  const summary = (0, import_extractor11.assembleSummary)(raw, options);
+  const summary = (0, import_extractor12.assembleSummary)(raw, options);
   if (subUnit.metadata !== void 0 && Object.keys(subUnit.metadata).length > 0) {
     summary.metadata = {
       ...summary.metadata ?? {},