npm - @suss/adapter-typescript - Versions diffs - 0.25.0 → 0.27.0 - Mend

@suss/adapter-typescript 0.25.0 → 0.27.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.cjs CHANGED Viewed

@@ -34,6 +34,7 @@ __export(index_exports, {
   GENERIC_TERMINALS: () => GENERIC_TERMINALS,
   NO_BARRIERS: () => NO_BARRIERS,
   ResolutionStore: () => ResolutionStore,
+  TSCONFIG_NAMES: () => TSCONFIG_NAMES,
   TypeScriptWhySession: () => TypeScriptWhySession,
   accessContextFor: () => accessContextFor,
   buildProjectHelperIndex: () => buildProjectHelperIndex,
@@ -41,7 +42,7 @@ __export(index_exports, {
   collectAncestorBranches: () => collectAncestorBranches,
   collectClientFieldAccesses: () => collectClientFieldAccesses,
   computeAdapterPacksDigest: () => computeAdapterPacksDigest,
-  computeContentHash: () => import_extractor10.computeContentHash,
+  computeContentHash: () => import_extractor11.computeContentHash,
   createProjectWithoutTsconfig: () => createProjectWithoutTsconfig,
   createTsDiscoveryContext: () => createTsDiscoveryContext,
   createTsSubUnitContext: () => createTsSubUnitContext,
@@ -78,10 +79,10 @@ module.exports = __toCommonJS(index_exports);
 // src/adapter.ts
 var import_node_path11 = __toESM(require("path"), 1);
-var import_ts_morph67 = require("ts-morph");
+var import_ts_morph68 = require("ts-morph");
 var import_behavioral_ir8 = require("@suss/behavioral-ir");
-var import_datalog6 = require("@suss/datalog");
-var import_extractor11 = require("@suss/extractor");
+var import_datalog5 = require("@suss/datalog");
+var import_extractor12 = require("@suss/extractor");
 // src/assembly.ts
 var import_ts_morph55 = require("ts-morph");
@@ -897,11 +898,11 @@ function tryExpandArrayIncludes(call) {
   return {
     type: "compound",
     op: "or",
-    operands: literalValues.map((lit6) => ({
+    operands: literalValues.map((lit5) => ({
       type: "comparison",
       left: subject,
       op: "eq",
-      right: lit6
+      right: lit5
     }))
   };
 }
@@ -2028,7 +2029,8 @@ function readFileText(project, filePath) {
     return null;
   }
 }
-function parseTsconfig(tsConfigFilePath) {
+function parseTsconfig(tsConfigFilePath, seen = /* @__PURE__ */ new Set()) {
+  seen.add(tsConfigFilePath);
   const configFile = import_ts_morph10.ts.readConfigFile(tsConfigFilePath, import_ts_morph10.ts.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
@@ -2041,7 +2043,18 @@ function parseTsconfig(tsConfigFilePath) {
     void 0,
     tsConfigFilePath
   );
-  return { fileNames: parsed.fileNames, options: parsed.options };
+  if (parsed.fileNames.length > 0) {
+    return { fileNames: parsed.fileNames, options: parsed.options };
+  }
+  const referenced = (parsed.projectReferences ?? []).map((reference) => import_ts_morph10.ts.resolveProjectReferencePath(reference)).filter((referencePath) => !seen.has(referencePath));
+  const fileNames = [
+    ...new Set(
+      referenced.flatMap(
+        (referencePath) => parseTsconfig(referencePath, seen).fileNames
+      )
+    )
+  ];
+  return { fileNames, options: parsed.options };
 }
 async function selectCandidateFiles(allFiles, packs, options) {
   const ungatedExists = packs.some(packIsUngated);
@@ -4399,178 +4412,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 +4507,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 +4556,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 +4627,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 +4647,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 +4686,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 +4719,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 +4731,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 +4755,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 +4782,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 +4803,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 +4818,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 +4829,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 +4857,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 +4901,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 +4933,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 +4962,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 +5137,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 +5161,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 +5184,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 +5196,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 +5205,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 +5241,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) {
@@ -5411,6 +5257,7 @@ function literalValueOf(value, resolution, isWanted) {
 }
 // src/discovery/clientCall.ts
+var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 function discoverClientCalls(sourceFile, match, kind, resolution) {
   const results = [];
   const isGlobal = match.importModule === "global";
@@ -5418,26 +5265,32 @@ 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 (isGlobal && import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
+      if (callee.getName() === match.importName && GLOBAL_OBJECTS.has(callee.getExpression().getText())) {
+        matched = true;
+      }
+    } else if (match.callable === true && isClientItself(callee, match, clientVarNames, resolution)) {
+      matched = true;
+    } else if (import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph20.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
+      if (isClientItself(subject, match, clientVarNames, resolution)) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -5463,6 +5316,9 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   });
   return results;
 }
+function isClientItself(subject, match, clientVarNames, resolution) {
+  return import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution);
+}
 function clientReceiverCheckFor(sourceFile, match, resolution) {
   const localName = resolveImportedLocalName(
     sourceFile,
@@ -5471,16 +5327,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 +5347,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 +5360,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 +5428,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 +5468,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 +5492,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 +5500,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 +5538,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 +5549,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 +5572,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 +5657,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 +5687,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 +5698,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 +5768,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 +5847,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 +5956,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 +6028,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 +6167,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 +6177,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 +6188,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 +6198,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 +6209,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 +6265,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 +6275,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 +6289,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 +6297,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 +6316,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 +6329,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 +6347,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 +6357,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 +6390,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 +6406,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 +6427,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 +6449,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 +6476,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 +6490,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 +6499,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 +6510,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 +6518,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 +6543,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 +6573,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 +6591,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 +6628,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 +6640,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 +6656,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 +6692,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 +6714,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 +6746,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 +6768,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 +6778,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 +6797,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 +6818,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 +6831,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 +6947,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 +6979,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 +6990,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 +7079,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 +7093,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 +7132,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 +7174,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 +7190,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 +7240,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 +7249,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 +7295,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 +7310,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 +7321,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 +7340,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 +7353,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 +7371,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 +7402,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 +7416,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 +7429,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 +7447,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 +7510,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 +7522,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 +7567,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 +7588,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 +7602,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 +7624,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 +7632,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 +7654,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 +7679,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 +7687,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 +7740,7 @@ function discoverPackageImports(sourceFile, match, kind, resolution) {
 }
 // src/discovery/registrationCall.ts
-var import_ts_morph34 = require("ts-morph");
+var import_ts_morph35 = require("ts-morph");
 var import_resolution3 = require("@suss/resolution");
 // src/resolve/routePath.ts
@@ -7892,35 +7748,169 @@ var import_values4 = require("@suss/values");
 function pathFromArgument(arg, resolution) {
   return (0, import_values4.pathOf)(evaluatedValue(arg, resolution));
 }
+function pathFromProperty(arg, property, resolution) {
+  const record2 = evaluatedValue(arg, resolution);
+  if (record2.kind !== "record") {
+    return void 0;
+  }
+  const field = record2.fields.get(property);
+  return field === void 0 ? void 0 : (0, import_values4.pathOf)((0, import_values4.force)(field.value));
+}
-// src/discovery/registrationCall.ts
-function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, resolution, mountPrefixes, expandedElsewhere) {
-  const results = [];
-  const registrationSubjects = registrationSubjectsOf(
-    sourceFile,
-    match.importModule,
-    match.importName,
-    resolution
-  );
-  const registrationMethods = match.registrationChain.map(
-    (c) => c.startsWith(".") ? c.slice(1) : c
+// src/discovery/wrapperFactory.ts
+var import_ts_morph34 = require("ts-morph");
+// src/resolve/unfollowedCall.ts
+var import_ts_morph33 = require("ts-morph");
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
+function isInExternalCode(sourceFile) {
+  if (sourceFile.isDeclarationFile()) {
+    return true;
+  }
+  return sourceFile.getFilePath().includes("/node_modules/");
+}
+function hasBody(fn) {
+  if (import_ts_morph33.Node.isFunctionDeclaration(fn) || import_ts_morph33.Node.isMethodDeclaration(fn) || import_ts_morph33.Node.isFunctionExpression(fn)) {
+    return fn.getBody?.() !== void 0;
+  }
+  return true;
+}
+function isDeclaredShape(declaration) {
+  return (import_ts_morph33.Node.isMethodSignature(declaration) || import_ts_morph33.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+}
+function isExternalDeclaration(declaration) {
+  if (isInExternalCode(declaration.getSourceFile())) {
+    return true;
+  }
+  if (import_ts_morph33.Node.isImportSpecifier(declaration) || import_ts_morph33.Node.isImportClause(declaration) || import_ts_morph33.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph33.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    return target === void 0 || isInExternalCode(target);
+  }
+  return declaresAnotherModule(declaration);
+}
+function declaresAnotherModule(declaration) {
+  const module2 = declaration.getFirstAncestorByKind(
+    import_ts_morph33.SyntaxKind.ModuleDeclaration
   );
-  if (registrationSubjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution, registrationMethods)) {
-    return results;
+  return module2 !== void 0 && import_ts_morph33.Node.isStringLiteral(module2.getNameNode());
+}
+function statesShapeOnly(declaration) {
+  if (isExternalDeclaration(declaration)) {
+    return false;
   }
-  sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
-      return;
-    }
-    const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee)) {
-      return;
-    }
-    const methodName = callee.getName();
-    if (!registrationMethods.includes(methodName)) {
-      return;
-    }
-    if (expandedAtCallSites(node, methodName, expandedElsewhere)) {
+  if (import_ts_morph33.Node.isMethodSignature(declaration) || import_ts_morph33.Node.isPropertySignature(declaration)) {
+    return true;
+  }
+  if (import_ts_morph33.Node.isFunctionDeclaration(declaration) || import_ts_morph33.Node.isMethodDeclaration(declaration)) {
+    return declaration.getBody() === void 0;
+  }
+  return false;
+}
+function declarationsBehind(symbol) {
+  if (symbol === void 0) {
+    return [];
+  }
+  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
+  return behind.length > 0 ? behind : symbol.getDeclarations();
+}
+function isParameterOf(declaration, scanning) {
+  return import_ts_morph33.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
+}
+function parameterIndexOf(declarations, scanning) {
+  if (scanning === void 0) {
+    return void 0;
+  }
+  const params = scanning.getParameters();
+  for (const declaration of declarations) {
+    const index = params.findIndex((param) => param === declaration);
+    if (index !== -1) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function classifyStop(declarations, scanning) {
+  if (declarations.length === 0) {
+    return "noDeclaration";
+  }
+  for (const declaration of declarations) {
+    if (!isInExternalCode(declaration.getSourceFile())) {
+      recordFileDependency(declaration.getSourceFile().getFilePath());
+    }
+  }
+  if (scanning !== void 0 && declarations.some((declaration) => isParameterOf(declaration, scanning))) {
+    return "callerSupplied";
+  }
+  if (declarations.every(isExternalDeclaration)) {
+    return "outsideRun";
+  }
+  if (declarations.some(statesShapeOnly)) {
+    return "noBody";
+  }
+  return "unsettledValue";
+}
+// src/discovery/wrapperFactory.ts
+function factoryNameOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph34.Node.isCallExpression(written)) {
+    return void 0;
+  }
+  const callee = written.getExpression();
+  if (import_ts_morph34.Node.isIdentifier(callee)) {
+    return callee.getText();
+  }
+  if (import_ts_morph34.Node.isPropertyAccessExpression(callee)) {
+    return callee.getName();
+  }
+  return void 0;
+}
+function factoryStopOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph34.Node.isCallExpression(written)) {
+    return null;
+  }
+  const callee = factoryNameOf(targetArg);
+  if (callee === void 0) {
+    return null;
+  }
+  const reason = classifyStop(
+    declarationsBehind(written.getExpression().getSymbol())
+  );
+  if (!(0, import_behavioral_ir2.worthRecording)(reason)) {
+    return null;
+  }
+  return { callee, reason: "unresolvedWrapper" };
+}
+// src/discovery/registrationCall.ts
+function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, resolution, mountPrefixes, expandedElsewhere, routeWrapperPattern) {
+  const results = [];
+  const registrationSubjects = registrationSubjectsOf(
+    sourceFile,
+    match.importModule,
+    match.importName,
+    resolution
+  );
+  const registrationMethods = match.registrationChain.map(
+    (c) => c.startsWith(".") ? c.slice(1) : c
+  );
+  if (registrationSubjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution, registrationMethods)) {
+    return results;
+  }
+  sourceFile.forEachDescendant((node) => {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
+      return;
+    }
+    const callee = node.getExpression();
+    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee)) {
+      return;
+    }
+    const methodName = callee.getName();
+    if (!registrationMethods.includes(methodName)) {
+      return;
+    }
+    if (expandedAtCallSites(node, methodName, expandedElsewhere)) {
       return;
     }
     const receiver = receiverOf(
@@ -7950,12 +7940,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     const registrationSubjectId = nodeId(subjectNode);
     let foundObjectArg = false;
     for (const arg of args) {
-      if (!import_ts_morph34.Node.isObjectLiteralExpression(arg)) {
+      if (!import_ts_morph35.Node.isObjectLiteralExpression(arg)) {
         continue;
       }
       foundObjectArg = true;
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph34.Node.isMethodDeclaration(prop)) {
+        if (import_ts_morph35.Node.isMethodDeclaration(prop)) {
           results.push({
             func: prop,
             kind,
@@ -7964,7 +7954,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           });
           continue;
         }
-        if (!import_ts_morph34.Node.isPropertyAssignment(prop)) {
+        if (!import_ts_morph35.Node.isPropertyAssignment(prop)) {
           continue;
         }
         const propInit = prop.getInitializer();
@@ -7996,6 +7986,13 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
         mountPrefixes
       );
       if (handler !== null) {
+        const chain = routeWrapperPattern === void 0 ? null : routeChainOf(
+          args.slice(0, -1),
+          routeWrapperPattern,
+          methodName,
+          routeInfo,
+          resolution
+        );
         results.push({
           func: handler,
           kind,
@@ -8003,8 +8000,13 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           name: methodName,
           nameKind: "label",
           registrationSubjectId,
-          ...routeInfo !== null ? { routeInfo } : {}
+          ...routeInfo !== null ? { routeInfo } : {},
+          ...chain === null || chain.references.length === 0 ? {} : { routeWrappers: chain.references },
+          ...chain === null || chain.unfollowed.length === 0 ? {} : { routeUnfollowed: chain.unfollowed }
         });
+        if (chain !== null) {
+          results.push(...chain.units);
+        }
         return;
       }
       if (routeInfo !== null && lastArg !== void 0 && namesAParameter(lastArg)) {
@@ -8050,6 +8052,47 @@ function declinedRegistration(call, callee, methodName, kind, receiver, resoluti
     }
   ];
 }
+function routeChainOf(listed, pattern, methodName, routeInfo, resolution) {
+  const chain = { units: [], references: [], unfollowed: [] };
+  const anonymousLabels = /* @__PURE__ */ new Map();
+  for (const arg of listed) {
+    const elements = import_ts_morph35.Node.isArrayLiteralExpression(arg) ? arg.getElements() : [arg];
+    for (const element of elements) {
+      const target = functionValueOf(element, resolution);
+      if (target === null) {
+        const stop = factoryStopOf(element);
+        if (stop !== null) {
+          chain.unfollowed.push(stop);
+        }
+        continue;
+      }
+      const ownName = functionNameOrAnon(target);
+      const named2 = ownName !== "<anon>";
+      const label = factoryNameOf(element) ?? methodName;
+      const seen = anonymousLabels.get(label) ?? 0;
+      if (!named2) {
+        anonymousLabels.set(label, seen + 1);
+      }
+      const name = named2 ? ownName : routeWrapperLabel(label, routeInfo, element, seen);
+      chain.units.push({
+        func: target,
+        kind: pattern.kind,
+        name,
+        pattern,
+        ...named2 ? {} : { nameKind: "label" }
+      });
+      chain.references.push({
+        file: target.getSourceFile().getFilePath(),
+        name
+      });
+    }
+  }
+  return chain;
+}
+function routeWrapperLabel(label, routeInfo, element, seen) {
+  const where = routeInfo === null ? `L${element.getStartLineNumber()}` : `${routeInfo.method} ${routeInfo.path}`;
+  return seen === 0 ? `${label}@${where}` : `${label}@${where}#${seen + 1}`;
+}
 function withMountPrefix(routeInfo, subjectNode, mountPrefixes) {
   if (routeInfo === null || mountPrefixes === void 0) {
     return routeInfo;
@@ -8077,13 +8120,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_morph35.Node.isIdentifier(subject)) {
     const known = subjects.get(subject.getText());
     if (known !== void 0) {
       return { kind: "routable", node: known };
     }
   }
-  if (resolution === void 0 || !(import_ts_morph34.Node.isIdentifier(subject) || import_ts_morph34.Node.isPropertyAccessExpression(subject))) {
+  if (resolution === void 0 || !(import_ts_morph35.Node.isIdentifier(subject) || import_ts_morph35.Node.isPropertyAccessExpression(subject))) {
     return NOT_A_ROUTABLE;
   }
   const construction = resolution.subjectConstructionOf(
@@ -8123,18 +8166,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_morph35.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && import_ts_morph34.Node.isCallExpression(init)) {
+      if (init !== void 0 && import_ts_morph35.Node.isCallExpression(init)) {
         setToCalls.add(node.getName());
       }
       return;
     }
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.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_morph35.Node.isPropertyAccessExpression(callee) || !import_ts_morph35.Node.isIdentifier(callee.getExpression())) {
       return;
     }
     const receiver = callee.getExpression().getText();
@@ -8161,18 +8204,18 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
     return subjects;
   }
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph34.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph35.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
       if (init === void 0) {
         return;
       }
-      const calleeText = import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init) ? init.getExpression().getText() : null;
+      const calleeText = import_ts_morph35.Node.isCallExpression(init) || import_ts_morph35.Node.isNewExpression(init) ? init.getExpression().getText() : null;
       if (calleeText !== null && spellings.includes(calleeText)) {
         subjects.set(node.getName(), init);
       }
       return;
     }
-    if (!import_ts_morph34.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph35.Node.isParameterDeclaration(node)) {
       return;
     }
     const typeNode = node.getTypeNode();
@@ -8193,7 +8236,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_morph35.Node.isCallExpression(written) || import_ts_morph35.Node.isNewExpression(written))) {
     return parameter;
   }
   return written;
@@ -8236,7 +8279,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_morph35.Node.isCallExpression(node) || import_ts_morph35.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph35.Node.isVariableDeclaration(node.getParent())) {
       constructions.push(node);
     }
   });
@@ -8254,11 +8297,11 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
   }
   const edges = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph34.Node.isCallExpression(node)) {
+    if (!import_ts_morph35.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
+    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -8272,7 +8315,7 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
     }
     const args = node.getArguments();
     const prefixArg = args[mount.prefixPosition];
-    if (prefixArg === void 0 || !(import_ts_morph34.Node.isStringLiteral(prefixArg) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
+    if (prefixArg === void 0 || !(import_ts_morph35.Node.isStringLiteral(prefixArg) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
       return;
     }
     const targetNodes = mountTargetsAmong(
@@ -8327,7 +8370,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
   } else {
     const args = call.getArguments();
     const arg = args[binding.method.position];
-    if (arg === void 0 || !(import_ts_morph34.Node.isStringLiteral(arg) || import_ts_morph34.Node.isNoSubstitutionTemplateLiteral(arg))) {
+    if (arg === void 0 || !(import_ts_morph35.Node.isStringLiteral(arg) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(arg))) {
       return null;
     }
     method = arg.getLiteralValue().toUpperCase();
@@ -8338,7 +8381,7 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
 }
 // src/discovery/registrationLoop.ts
-var import_ts_morph35 = require("ts-morph");
+var import_ts_morph36 = require("ts-morph");
 function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
   const results = [];
   const guard = receiverGuard(sourceFile, match.receiver, resolution);
@@ -8346,7 +8389,7 @@ function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
     return results;
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph35.Node.isForOfStatement(node)) {
+    if (!import_ts_morph36.Node.isForOfStatement(node)) {
       return;
     }
     const expanded = tryExpandLoop(node, match, kind, resolution, guard);
@@ -8409,13 +8452,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_morph36.Node.isVariableDeclarationList(initializer)) {
     const decls = initializer.getDeclarations();
     if (decls.length !== 1) {
       return null;
     }
     const nameNode = decls[0]?.getNameNode();
-    if (nameNode !== void 0 && import_ts_morph35.Node.isIdentifier(nameNode)) {
+    if (nameNode !== void 0 && import_ts_morph36.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -8428,14 +8471,14 @@ function bodyReferencesLoopVar(loop, name) {
     if (referenced) {
       return;
     }
-    if (!import_ts_morph35.Node.isCallExpression(node)) {
+    if (!import_ts_morph36.Node.isCallExpression(node)) {
       return;
     }
     node.forEachDescendant((inner) => {
       if (referenced) {
         return;
       }
-      if (import_ts_morph35.Node.isIdentifier(inner) && inner.getText() === name) {
+      if (import_ts_morph36.Node.isIdentifier(inner) && inner.getText() === name) {
         referenced = true;
       }
     });
@@ -8445,11 +8488,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_morph36.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph35.Node.isPropertyAccessExpression(callee) && !import_ts_morph35.Node.isElementAccessExpression(callee)) {
+    if (!import_ts_morph36.Node.isPropertyAccessExpression(callee) && !import_ts_morph36.Node.isElementAccessExpression(callee)) {
       return;
     }
     const subject = callee.getExpression();
@@ -8469,11 +8512,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_morph36.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
       handler = { func: prop, name: shape.handlerKey };
       continue;
     }
-    if (!import_ts_morph35.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph36.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const name = prop.getName();
@@ -8496,111 +8539,19 @@ 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_morph36.Node.isStringLiteral(node) || import_ts_morph36.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_morph36.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 // src/discovery/registrationTemplate.ts
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_ts_morph37 = require("ts-morph");
 var import_resolution4 = require("@suss/resolution");
-// src/resolve/unfollowedCall.ts
-var import_ts_morph36 = require("ts-morph");
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
-function isInExternalCode(sourceFile) {
-  if (sourceFile.isDeclarationFile()) {
-    return true;
-  }
-  return sourceFile.getFilePath().includes("/node_modules/");
-}
-function hasBody(fn) {
-  if (import_ts_morph36.Node.isFunctionDeclaration(fn) || import_ts_morph36.Node.isMethodDeclaration(fn) || import_ts_morph36.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());
-}
-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();
-    return target === void 0 || isInExternalCode(target);
-  }
-  return declaresAnotherModule(declaration);
-}
-function declaresAnotherModule(declaration) {
-  const module2 = declaration.getFirstAncestorByKind(
-    import_ts_morph36.SyntaxKind.ModuleDeclaration
-  );
-  return module2 !== void 0 && import_ts_morph36.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)) {
-    return true;
-  }
-  if (import_ts_morph36.Node.isFunctionDeclaration(declaration) || import_ts_morph36.Node.isMethodDeclaration(declaration)) {
-    return declaration.getBody() === void 0;
-  }
-  return false;
-}
-function declarationsBehind(symbol) {
-  if (symbol === void 0) {
-    return [];
-  }
-  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
-  return behind.length > 0 ? behind : symbol.getDeclarations();
-}
-function isParameterOf(declaration, scanning) {
-  return import_ts_morph36.Node.isParameterDeclaration(declaration) && declaration.getParent() === scanning;
-}
-function parameterIndexOf(declarations, scanning) {
-  if (scanning === void 0) {
-    return void 0;
-  }
-  const params = scanning.getParameters();
-  for (const declaration of declarations) {
-    const index = params.findIndex((param) => param === declaration);
-    if (index !== -1) {
-      return index;
-    }
-  }
-  return void 0;
-}
-function classifyStop(declarations, scanning) {
-  if (declarations.length === 0) {
-    return "noDeclaration";
-  }
-  for (const declaration of declarations) {
-    if (!isInExternalCode(declaration.getSourceFile())) {
-      recordFileDependency(declaration.getSourceFile().getFilePath());
-    }
-  }
-  if (scanning !== void 0 && declarations.some((declaration) => isParameterOf(declaration, scanning))) {
-    return "callerSupplied";
-  }
-  if (declarations.every(isExternalDeclaration)) {
-    return "outsideRun";
-  }
-  if (declarations.some(statesShapeOnly)) {
-    return "noBody";
-  }
-  return "unsettledValue";
-}
-// src/discovery/registrationTemplate.ts
 function discoverRegistrationTemplates(sourceFile, match, kind, resolution, mountPrefixes) {
   const results = [];
   for (const node of helperCallsOf(sourceFile, match, resolution)) {
@@ -8656,7 +8607,7 @@ 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,
@@ -8871,7 +8822,7 @@ function writtenSdl(expr) {
 }
 // src/discovery/index.ts
-function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElsewhere) {
+function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElsewhere, routeWrapperPattern) {
   if (pattern.match.type === "namedExport") {
     return discoverNamedExports(
       sourceFile,
@@ -8888,7 +8839,8 @@ function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElse
       pattern.bindingExtraction,
       resolution,
       mountPrefixes,
-      expandedElsewhere
+      expandedElsewhere,
+      routeWrapperPattern
     );
   }
   if (pattern.match.type === "registrationTemplate") {
@@ -8994,19 +8946,26 @@ function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElse
   }
   return [];
 }
+function routeWrapperPatternOf(patterns) {
+  return patterns.find(
+    (pattern) => pattern.wraps !== void 0 && "method" in pattern.wraps && pattern.wraps.continuationParam !== void 0 && pattern.wraps.throwParam === void 0 && pattern.wraps.arity === void 0 && pattern.wraps.scopePosition === void 0
+  );
+}
 function discoverUnits(sourceFile, patterns, resolution, mountPrefixes, expandedElsewhere) {
   const store = resolution ?? new ResolutionStore();
   const allResults = [];
+  const routeWrapperPattern = routeWrapperPatternOf(patterns);
   for (const pattern of patterns) {
     const found = runPattern(
       sourceFile,
       pattern,
       store,
       mountPrefixes,
-      expandedElsewhere
+      expandedElsewhere,
+      routeWrapperPattern
     );
     for (const unit of found) {
-      unit.pattern = pattern;
+      unit.pattern ??= pattern;
     }
     allResults.push(...found);
   }
@@ -11494,8 +11453,8 @@ function implementationBeside(declaration, name) {
         return candidate;
       }
     }
-    const variable4 = source.getVariableDeclaration(name);
-    const fn = variable4 === void 0 ? null : asFunctionLike(variable4);
+    const variable3 = source.getVariableDeclaration(name);
+    const fn = variable3 === void 0 ? null : asFunctionLike(variable3);
     if (fn !== null) {
       return fn;
     }
@@ -12817,6 +12776,154 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
   return null;
 }
+// src/diagnostics.ts
+var import_node_path7 = __toESM(require("path"), 1);
+var import_ts_morph58 = require("ts-morph");
+var import_extractor6 = require("@suss/extractor");
+var DEFAULT_RESOLUTION = {
+  moduleResolution: import_ts_morph58.ts.ModuleResolutionKind.Bundler,
+  target: import_ts_morph58.ts.ScriptTarget.ESNext,
+  module: import_ts_morph58.ts.ModuleKind.ESNext
+};
+function resolutionContext(args) {
+  if (args.tsConfigFilePath !== void 0) {
+    const configFile = import_ts_morph58.ts.readConfigFile(
+      args.tsConfigFilePath,
+      import_ts_morph58.ts.sys.readFile
+    );
+    if (configFile.error !== void 0) {
+      return null;
+    }
+    const dir = import_node_path7.default.dirname(args.tsConfigFilePath);
+    const parsed = import_ts_morph58.ts.parseJsonConfigFileContent(
+      configFile.config,
+      import_ts_morph58.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_morph58.ts.resolveModuleName(
+      gate,
+      context.containingFile,
+      context.options,
+      import_ts_morph58.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);
@@ -12896,7 +13003,7 @@ var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 var import_graphql2 = require("graphql");
 var import_picomatch2 = __toESM(require("picomatch"), 1);
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
 function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const scopes = compileOperationScopes(packs);
@@ -12936,11 +13043,11 @@ function fragmentsRegisteredIn(sourceFiles) {
   const registered = /* @__PURE__ */ new Set();
   for (const sourceFile of sourceFiles) {
     sourceFile.forEachDescendant((node) => {
-      if (!import_ts_morph58.Node.isCallExpression(node)) {
+      if (!import_ts_morph59.Node.isCallExpression(node)) {
         return;
       }
       const argument = node.getArguments()[0];
-      if (argument === void 0 || !import_ts_morph58.Node.isNoSubstitutionTemplateLiteral(argument)) {
+      if (argument === void 0 || !import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(argument)) {
         return;
       }
       for (const name of fragmentOnlyDocumentNames(argument.getLiteralText())) {
@@ -13127,7 +13234,7 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheConstruction === null) {
     return "unknown";
   }
-  if (!import_ts_morph58.Node.isNewExpression(cacheConstruction) && !import_ts_morph58.Node.isCallExpression(cacheConstruction)) {
+  if (!import_ts_morph59.Node.isNewExpression(cacheConstruction) && !import_ts_morph59.Node.isCallExpression(cacheConstruction)) {
     return "unknown";
   }
   const args = cacheConstruction.getArguments();
@@ -13141,15 +13248,15 @@ function constructionRegistryStatus(construction, spec) {
   if (cacheOptions.getProperty(spec.registryProperty) !== void 0) {
     return "configured";
   }
-  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph58.Node.isSpreadAssignment(property));
+  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph59.Node.isSpreadAssignment(property));
   return hasSpread ? "unknown" : "absent";
 }
 function firstArgumentObjectLiteral(construction) {
-  if (!import_ts_morph58.Node.isNewExpression(construction) && !import_ts_morph58.Node.isCallExpression(construction)) {
+  if (!import_ts_morph59.Node.isNewExpression(construction) && !import_ts_morph59.Node.isCallExpression(construction)) {
     return null;
   }
   const arg = construction.getArguments()[0];
-  if (arg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !import_ts_morph59.Node.isObjectLiteralExpression(arg)) {
     return null;
   }
   return arg;
@@ -13159,10 +13266,10 @@ function propertyValueOf2(options, name) {
   if (property === void 0) {
     return null;
   }
-  if (import_ts_morph58.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph59.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph58.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph59.Node.isShorthandPropertyAssignment(property)) {
     const symbol = property.getProject().getTypeChecker().getShorthandAssignmentValueSymbol(property);
     return symbol?.getValueDeclaration() ?? null;
   }
@@ -13172,13 +13279,13 @@ function resolveToConstructionOf(expression, cacheClass) {
   let current2 = expression;
   for (let hop = 0; hop < 4 && current2 !== void 0; hop += 1) {
     current2 = unwrapExpression2(current2);
-    if (import_ts_morph58.Node.isVariableDeclaration(current2)) {
+    if (import_ts_morph59.Node.isVariableDeclaration(current2)) {
       current2 = current2.getInitializer();
       continue;
     }
-    if (import_ts_morph58.Node.isNewExpression(current2) || import_ts_morph58.Node.isCallExpression(current2)) {
+    if (import_ts_morph59.Node.isNewExpression(current2) || import_ts_morph59.Node.isCallExpression(current2)) {
       const callee = current2.getExpression();
-      if (callee === void 0 || !import_ts_morph58.Node.isIdentifier(callee)) {
+      if (callee === void 0 || !import_ts_morph59.Node.isIdentifier(callee)) {
         return null;
       }
       const local = localImportName(
@@ -13188,11 +13295,11 @@ function resolveToConstructionOf(expression, cacheClass) {
       );
       return local !== null && callee.getText() === local ? current2 : null;
     }
-    if (!import_ts_morph58.Node.isIdentifier(current2)) {
+    if (!import_ts_morph59.Node.isIdentifier(current2)) {
       return null;
     }
     const declaration = current2.getSymbol()?.getValueDeclaration();
-    if (declaration === void 0 || !import_ts_morph58.Node.isVariableDeclaration(declaration)) {
+    if (declaration === void 0 || !import_ts_morph59.Node.isVariableDeclaration(declaration)) {
       return null;
     }
     current2 = declaration.getInitializer();
@@ -13203,11 +13310,11 @@ function unwrapExpression2(node) {
   return peelSyntax(node);
 }
 function isConstructionNamed(node, localName) {
-  if (!import_ts_morph58.Node.isNewExpression(node) && !import_ts_morph58.Node.isCallExpression(node)) {
+  if (!import_ts_morph59.Node.isNewExpression(node) && !import_ts_morph59.Node.isCallExpression(node)) {
     return false;
   }
   const callee = node.getExpression();
-  return callee !== void 0 && import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === localName;
+  return callee !== void 0 && import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function localImportName(sourceFile, importModule, importName) {
   for (const one of namedImportsOf(sourceFile, [importModule], {
@@ -13221,11 +13328,11 @@ function localImportName(sourceFile, importModule, importName) {
 }
 function constructionRef(node, uriProperty, resolution) {
   const optionsArg = node.getArguments()[0];
-  if (optionsArg === void 0 || !import_ts_morph58.Node.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg === void 0 || !import_ts_morph59.Node.isObjectLiteralExpression(optionsArg)) {
     return null;
   }
   const property = optionsArg.getProperty(uriProperty);
-  if (property === void 0 || !import_ts_morph58.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph59.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
@@ -13240,10 +13347,10 @@ function constructionRef(node, uriProperty, resolution) {
 }
 // src/discovery/helperIndex.ts
-var import_ts_morph60 = require("ts-morph");
+var import_ts_morph61 = require("ts-morph");
 // src/discovery/helperReading.ts
-var import_ts_morph59 = require("ts-morph");
+var import_ts_morph60 = require("ts-morph");
 var UNREAD = { as: "unread" };
 function readHelperSinks(helper) {
   const positions = parameterPositions(helper);
@@ -13253,11 +13360,11 @@ function readHelperSinks(helper) {
     return sinks;
   }
   body.forEachDescendant((node) => {
-    if (!import_ts_morph59.Node.isCallExpression(node)) {
+    if (!import_ts_morph60.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    const [method, receiver] = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
+    const [method, receiver] = import_ts_morph60.Node.isPropertyAccessExpression(callee) ? [callee.getName(), readValue(callee.getExpression(), positions)] : [null, UNREAD];
     sinks.push({
       method,
       receiver,
@@ -13277,25 +13384,25 @@ function parameterPositions(helper) {
   return positions;
 }
 function readValue(node, positions) {
-  if (import_ts_morph59.Node.isStringLiteral(node) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph60.Node.isStringLiteral(node) || import_ts_morph60.Node.isNoSubstitutionTemplateLiteral(node)) {
     return { as: "text", text: node.getLiteralValue() };
   }
-  if (import_ts_morph59.Node.isTemplateExpression(node)) {
+  if (import_ts_morph60.Node.isTemplateExpression(node)) {
     return templateText(node, positions);
   }
-  if (import_ts_morph59.Node.isIdentifier(node)) {
+  if (import_ts_morph60.Node.isIdentifier(node)) {
     const position = positions.get(node.getText());
     return position === void 0 ? UNREAD : { as: "parameter", position };
   }
-  if (import_ts_morph59.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph60.Node.isPropertyAccessExpression(node)) {
     const target = node.getExpression();
-    const position = import_ts_morph59.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
+    const position = import_ts_morph60.Node.isIdentifier(target) ? positions.get(target.getText()) : void 0;
     return position === void 0 ? UNREAD : { as: "parameter", position, property: node.getName() };
   }
-  if (import_ts_morph59.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph60.Node.isObjectLiteralExpression(node)) {
     return objectValue(node, positions);
   }
-  if (import_ts_morph59.Node.isCallExpression(node)) {
+  if (import_ts_morph60.Node.isCallExpression(node)) {
     return {
       as: "call",
       callee: node.getExpression().getText(),
@@ -13305,13 +13412,13 @@ function readValue(node, positions) {
   return UNREAD;
 }
 function templateText(node, positions) {
-  if (!import_ts_morph59.Node.isTemplateExpression(node)) {
+  if (!import_ts_morph60.Node.isTemplateExpression(node)) {
     return UNREAD;
   }
   let text = node.getHead().getLiteralText();
   for (const span of node.getTemplateSpans()) {
     const expression = span.getExpression();
-    const position = import_ts_morph59.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
+    const position = import_ts_morph60.Node.isIdentifier(expression) ? positions.get(expression.getText()) : void 0;
     if (position === void 0) {
       return UNREAD;
     }
@@ -13320,12 +13427,12 @@ function templateText(node, positions) {
   return { as: "text", text };
 }
 function objectValue(node, positions) {
-  if (!import_ts_morph59.Node.isObjectLiteralExpression(node)) {
+  if (!import_ts_morph60.Node.isObjectLiteralExpression(node)) {
     return UNREAD;
   }
   const properties = {};
   for (const property of node.getProperties()) {
-    if (!import_ts_morph59.Node.isPropertyAssignment(property)) {
+    if (!import_ts_morph60.Node.isPropertyAssignment(property)) {
       continue;
     }
     const initializer = property.getInitializer();
@@ -13340,7 +13447,7 @@ function objectValue(node, positions) {
   return { as: "object", properties };
 }
 function propertyKey(name) {
-  return import_ts_morph59.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
+  return import_ts_morph60.Node.isStringLiteral(name) ? name.getLiteralValue() : name.getText();
 }
 // src/discovery/helperIndex.ts
@@ -13470,11 +13577,11 @@ function registrationMatchesOf(pack) {
 }
 function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph60.Node.isCallExpression(node)) {
+    if (!import_ts_morph61.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph60.Node.isIdentifier(callee)) {
+    if (!import_ts_morph61.Node.isIdentifier(callee)) {
       return;
     }
     const handedOver = subjectArgument(node, subjects, match, resolution);
@@ -13489,12 +13596,12 @@ function collectHandOffs(sourceFile, subjects, match, resolution, found) {
   });
 }
 function subjectArgument(call, subjects, match, resolution) {
-  if (!import_ts_morph60.Node.isCallExpression(call)) {
+  if (!import_ts_morph61.Node.isCallExpression(call)) {
     return -1;
   }
   const args = call.getArguments();
   for (const [position, argument] of args.entries()) {
-    if (!import_ts_morph60.Node.isIdentifier(argument) && !import_ts_morph60.Node.isPropertyAccessExpression(argument)) {
+    if (!import_ts_morph61.Node.isIdentifier(argument) && !import_ts_morph61.Node.isPropertyAccessExpression(argument)) {
       continue;
     }
     if (subjectNodeFor(argument, subjects, match, resolution) !== void 0) {
@@ -13553,10 +13660,10 @@ function declaredFunctions(sourceFile) {
       found.push([name, declaration]);
     }
   }
-  for (const variable4 of sourceFile.getVariableDeclarations()) {
-    const initializer = variable4.getInitializer();
-    if (initializer !== void 0 && (import_ts_morph60.Node.isArrowFunction(initializer) || import_ts_morph60.Node.isFunctionExpression(initializer))) {
-      found.push([variable4.getName(), initializer]);
+  for (const variable3 of sourceFile.getVariableDeclarations()) {
+    const initializer = variable3.getInitializer();
+    if (initializer !== void 0 && (import_ts_morph61.Node.isArrowFunction(initializer) || import_ts_morph61.Node.isFunctionExpression(initializer))) {
+      found.push([variable3.getName(), initializer]);
     }
   }
   return found;
@@ -13648,7 +13755,7 @@ function recordEdge(edgesByChild, candidate) {
 }
 // src/discovery/wrapperIndex.ts
-var import_ts_morph61 = require("ts-morph");
+var import_ts_morph62 = require("ts-morph");
 var import_resolution6 = require("@suss/resolution");
 var NO_WRAPPERS = {
   wrappersFor: () => [],
@@ -13772,11 +13879,11 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
   const candidates = [];
   const unresolved = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph61.Node.isCallExpression(node)) {
+    if (!import_ts_morph62.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph61.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
+    if (!import_ts_morph62.Node.isPropertyAccessExpression(callee) || callee.getName() !== wraps.method) {
       return;
     }
     const subjectNode = subjectNodeFor(
@@ -13871,7 +13978,7 @@ function discoverConstructorOptions(sourceFile, pattern, wraps, subjects, resolu
   return { candidates, unresolved };
 }
 function constructorOptionOf(construction, wraps, resolution) {
-  if (!(import_ts_morph61.Node.isNewExpression(construction) || import_ts_morph61.Node.isCallExpression(construction))) {
+  if (!(import_ts_morph62.Node.isNewExpression(construction) || import_ts_morph62.Node.isCallExpression(construction))) {
     return void 0;
   }
   const optionsArg = construction.getArguments()[wraps.targetPosition];
@@ -13901,6 +14008,7 @@ function candidateOf(registration, pattern, sourceFile) {
     reference: {
       file: target.getSourceFile().getFilePath(),
       name: named2 ? functionNameOrAnon(target) : label,
+      ...named2 ? {} : { line: target.getStartLineNumber() },
       ...onThrow ? { onThrow: true } : {},
       ...scope === void 0 ? {} : { scope }
     }
@@ -13909,37 +14017,6 @@ function candidateOf(registration, pattern, sourceFile) {
 function labelFor(targetArg, wraps) {
   return factoryNameOf(targetArg) ?? wraps.method;
 }
-function factoryNameOf(targetArg) {
-  const written = factKeyOf(targetArg);
-  if (!import_ts_morph61.Node.isCallExpression(written)) {
-    return void 0;
-  }
-  const callee = written.getExpression();
-  if (import_ts_morph61.Node.isIdentifier(callee)) {
-    return callee.getText();
-  }
-  if (import_ts_morph61.Node.isPropertyAccessExpression(callee)) {
-    return callee.getName();
-  }
-  return void 0;
-}
-function factoryStopOf(targetArg) {
-  const written = factKeyOf(targetArg);
-  if (!import_ts_morph61.Node.isCallExpression(written)) {
-    return null;
-  }
-  const callee = factoryNameOf(targetArg);
-  if (callee === void 0) {
-    return null;
-  }
-  const reason = classifyStop(
-    declarationsBehind(written.getExpression().getSymbol())
-  );
-  if (!(0, import_behavioral_ir2.worthRecording)(reason)) {
-    return null;
-  }
-  return { callee, reason: "unresolvedWrapper" };
-}
 function mountedAt(subjectId, mountPrefixes, scope) {
   const prefix = mountPrefixes?.prefixForId?.(subjectId) ?? "";
   return (0, import_resolution6.joinMountedPath)(prefix, scope);
@@ -13956,7 +14033,7 @@ function scopeOf(args, wraps, resolution) {
 }
 // src/discoveryContext.ts
-var import_ts_morph62 = require("ts-morph");
+var import_ts_morph63 = require("ts-morph");
 function createTsDiscoveryContext(resolution) {
   const store = resolution ?? new ResolutionStore();
   return {
@@ -13991,7 +14068,7 @@ function exportedFunctions(sourceFile, resolution) {
   return out;
 }
 function exportedFunction(decl, resolution) {
-  const writtenAgain = import_ts_morph62.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
+  const writtenAgain = import_ts_morph63.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
   if (!writtenAgain) {
     const declared = resolveDeclarationToFunction(decl);
     if (declared !== null) {
@@ -14012,7 +14089,7 @@ function valueToAskAbout(decl, writtenAgain) {
   if (writtenAgain) {
     return decl;
   }
-  const value = import_ts_morph62.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
+  const value = import_ts_morph63.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
   return couldStillNameAFunction(value) ? value : null;
 }
 function resolveDeclarationToFunction(decl) {
@@ -14020,18 +14097,18 @@ function resolveDeclarationToFunction(decl) {
   if (fn !== null) {
     return fn;
   }
-  if (import_ts_morph62.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph63.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph62.Node.isArrowFunction(init) || import_ts_morph62.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init))) {
       return init;
     }
   }
   return null;
 }
 function hasJsxReturn(func) {
-  if (import_ts_morph62.Node.isArrowFunction(func)) {
+  if (import_ts_morph63.Node.isArrowFunction(func)) {
     const body2 = func.getBody();
-    if (import_ts_morph62.Node.isExpression(body2) && isJsxOrFragment(body2)) {
+    if (import_ts_morph63.Node.isExpression(body2) && isJsxOrFragment(body2)) {
       return true;
     }
   }
@@ -14045,11 +14122,11 @@ function hasJsxReturn(func) {
       traversal.stop();
       return;
     }
-    if (node !== func && (import_ts_morph62.Node.isFunctionDeclaration(node) || import_ts_morph62.Node.isFunctionExpression(node) || import_ts_morph62.Node.isArrowFunction(node) || import_ts_morph62.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph63.Node.isFunctionDeclaration(node) || import_ts_morph63.Node.isFunctionExpression(node) || import_ts_morph63.Node.isArrowFunction(node) || import_ts_morph63.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph62.Node.isReturnStatement(node)) {
+    if (import_ts_morph63.Node.isReturnStatement(node)) {
       const expr = node.getExpression();
       if (expr !== void 0 && isJsxOrFragment(expr)) {
         found = true;
@@ -14060,7 +14137,7 @@ function hasJsxReturn(func) {
 }
 function isJsxOrFragment(node) {
   const current2 = peelParens(node);
-  return import_ts_morph62.Node.isJsxElement(current2) || import_ts_morph62.Node.isJsxSelfClosingElement(current2) || import_ts_morph62.Node.isJsxFragment(current2);
+  return import_ts_morph63.Node.isJsxElement(current2) || import_ts_morph63.Node.isJsxSelfClosingElement(current2) || import_ts_morph63.Node.isJsxFragment(current2);
 }
 // src/graphqlContract.ts
@@ -14143,7 +14220,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 +14228,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() },
@@ -14183,133 +14260,11 @@ function createReferenceIndex(sourceFiles) {
   };
 }
-// src/resolve/boundaryEffects.ts
-var import_datalog3 = require("@suss/datalog");
-var EFFECT_RULES = [
-  (0, import_datalog3.rule)(
-    "reachFrom",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("e")],
-    [(0, import_datalog3.lit)("entry", (0, import_datalog3.variable)("e"))]
-  ),
-  (0, import_datalog3.rule)(
-    "reachFrom",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("v")],
-    [
-      (0, import_datalog3.lit)("reachFrom", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("u")),
-      (0, import_datalog3.lit)("calls", (0, import_datalog3.variable)("u"), (0, import_datalog3.variable)("v"))
-    ]
-  ),
-  (0, import_datalog3.rule)(
-    "boundaryEffect",
-    [(0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("kind"), (0, import_datalog3.variable)("target")],
-    [
-      (0, import_datalog3.lit)("reachFrom", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("u")),
-      (0, import_datalog3.lit)("unitEffect", (0, import_datalog3.variable)("u"), (0, import_datalog3.variable)("kind"), (0, import_datalog3.variable)("target"))
-    ]
-  )
-];
-function bindingLabel(binding) {
-  const semantics = binding.semantics;
-  if (semantics.name === "rest") {
-    return `${semantics.method} ${semantics.path}`;
-  }
-  if (semantics.name === "storage") {
-    return `${semantics.storageSystem}:${semantics.container}`;
-  }
-  if (semantics.name === "message-bus") {
-    return `${semantics.messageBus}:${semantics.channel}`;
-  }
-  if (semantics.name === "runtime-config") {
-    return semantics.instanceName;
-  }
-  if (semantics.name === "graphql-resolver") {
-    return `${semantics.typeName}.${semantics.fieldName}`;
-  }
-  if (semantics.name === "graphql-operation") {
-    return `${semantics.operationType} ${semantics.operationName ?? ""}`.trim();
-  }
-  if ("exportName" in semantics || "module" in semantics) {
-    return semantics.exportName ?? semantics.module ?? binding.recognition;
-  }
-  if ("instanceName" in semantics && semantics.instanceName !== null) {
-    return `${semantics.deploymentTarget}:${semantics.instanceName}`;
-  }
-  return binding.recognition;
-}
-function effectFact(effect) {
-  if (effect.type === "invocation") {
-    return { kind: "invocation", target: effect.callee };
-  }
-  if (effect.type === "mutation") {
-    return { kind: "mutation", target: `${effect.operation}:${effect.target}` };
-  }
-  if (effect.type === "emission") {
-    return { kind: "emission", target: effect.event };
-  }
-  if (effect.type === "stateChange") {
-    return { kind: "stateChange", target: effect.variable };
-  }
-  if (effect.type === "interaction") {
-    return { kind: "interaction", target: bindingLabel(effect.binding) };
-  }
-  return null;
-}
-function deriveBoundaryEffects(summaries, facts) {
-  const { db, unitKeyBySummary } = facts;
-  for (const summary of summaries) {
-    const key = unitKeyBySummary.get(summary);
-    if (key === void 0) {
-      continue;
-    }
-    for (const transition of summary.transitions) {
-      for (const effect of transition.effects) {
-        const fact2 = effectFact(effect);
-        if (fact2 !== null) {
-          db.add("unitEffect", [key, fact2.kind, fact2.target]);
-        }
-      }
-    }
-  }
-  (0, import_datalog3.evaluate)(db, EFFECT_RULES);
-  const ownByEntry = /* @__PURE__ */ new Map();
-  for (const [unit, kind, target] of db.facts("unitEffect")) {
-    const bucket = ownByEntry.get(String(unit)) ?? /* @__PURE__ */ new Set();
-    bucket.add(`${kind}\0${target}`);
-    ownByEntry.set(String(unit), bucket);
-  }
-  const closureByEntry = /* @__PURE__ */ new Map();
-  for (const [entry, kind, target] of db.facts("boundaryEffect")) {
-    const entryKey2 = String(entry);
-    const bucket = closureByEntry.get(entryKey2) ?? [];
-    bucket.push({
-      kind: String(kind),
-      target: String(target),
-      transitive: !(ownByEntry.get(entryKey2)?.has(`${kind}\0${target}`) ?? false)
-    });
-    closureByEntry.set(entryKey2, bucket);
-  }
-  for (const summary of summaries) {
-    const key = unitKeyBySummary.get(summary);
-    if (key === void 0 || !db.has("entry", [key])) {
-      continue;
-    }
-    const effects = closureByEntry.get(key);
-    if (effects === void 0 || effects.length === 0) {
-      continue;
-    }
-    const sorted = [...effects].sort(
-      (a, b) => `${a.kind}:${a.target}`.localeCompare(`${b.kind}:${b.target}`)
-    );
-    summary.metadata = { ...summary.metadata, effectsClosure: sorted };
-  }
-  return summaries;
-}
 // src/resolve/reachableClosure.ts
-var import_ts_morph63 = require("ts-morph");
+var import_ts_morph64 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
-var import_datalog4 = require("@suss/datalog");
-var import_extractor7 = require("@suss/extractor");
+var import_datalog3 = require("@suss/datalog");
+var import_extractor8 = require("@suss/extractor");
 var GENERIC_TERMINALS = [
   { kind: "return", match: { type: "returnStatement" }, extraction: {} },
   { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
@@ -14339,7 +14294,7 @@ function targetOf(node) {
   };
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph63.Node.isCallExpression(call)) {
+  if (!import_ts_morph64.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -14352,7 +14307,7 @@ function resolveCallee(call, calleeName, scan) {
     }
   }
   const resolveSources = scan.resolveCallableSources;
-  if (resolveSources !== void 0 && import_ts_morph63.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+  if (resolveSources !== void 0 && import_ts_morph64.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
     const sources = resolveSources(callee, scan.reachedFrom);
     const only = sources.length === 1 ? sources[0] : void 0;
     const resolved = only === void 0 ? null : resolveDecl(only, calleeName);
@@ -14398,11 +14353,11 @@ function passedPositionKey(target, position) {
   return `${offsetKeyFor(target.file, target.span)}#${position}`;
 }
 function resolveJsxReference(node, scan) {
-  if (!import_ts_morph63.Node.isJsxOpeningElement(node) && !import_ts_morph63.Node.isJsxSelfClosingElement(node)) {
+  if (!import_ts_morph64.Node.isJsxOpeningElement(node) && !import_ts_morph64.Node.isJsxSelfClosingElement(node)) {
     return null;
   }
   const tag = node.getTagNameNode();
-  if (!import_ts_morph63.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
+  if (!import_ts_morph64.Node.isIdentifier(tag) || !/^[A-Z]/.test(tag.getText())) {
     return null;
   }
   const name = tag.getText();
@@ -14448,12 +14403,12 @@ function collectReachable(func, scan) {
     candidates.push(outcome.candidate);
   };
   const recordPassedArgs = (call, calleeText, calleeOutcome) => {
-    if (!import_ts_morph63.Node.isCallExpression(call)) {
+    if (!import_ts_morph64.Node.isCallExpression(call)) {
       return;
     }
     const calleeTarget = declaredAtOf(calleeOutcome);
     call.getArguments().forEach((arg, position) => {
-      if (!import_ts_morph63.Node.isIdentifier(arg)) {
+      if (!import_ts_morph64.Node.isIdentifier(arg)) {
         return;
       }
       const resolved = functionTargetOf(arg);
@@ -14473,7 +14428,7 @@ function collectReachable(func, scan) {
       record2(jsx.outcome);
       return;
     }
-    if (!import_ts_morph63.Node.isCallExpression(node)) {
+    if (!import_ts_morph64.Node.isCallExpression(node)) {
       return;
     }
     const calleeText = normalizeCallee(node.getExpression().getText());
@@ -14522,16 +14477,16 @@ 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"))]),
-  (0, import_datalog4.rule)(
+  (0, import_datalog3.rule)("reachable", [(0, import_datalog3.variable)("f")], [(0, import_datalog3.lit)("entry", (0, import_datalog3.variable)("f"))]),
+  (0, import_datalog3.rule)(
     "reachable",
-    [(0, import_datalog4.variable)("g")],
+    [(0, import_datalog3.variable)("g")],
     [
-      (0, import_datalog4.lit)("reachable", (0, import_datalog4.variable)("f")),
-      (0, import_datalog4.lit)("calls", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("g"))
+      (0, import_datalog3.lit)("reachable", (0, import_datalog3.variable)("f")),
+      (0, import_datalog3.lit)("calls", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("g"))
     ]
   )
 ];
@@ -14559,7 +14514,7 @@ function recognizerOnlyRoots(packsByFile) {
       }
       for (const declaration of variableStatement.getDeclarations()) {
         const init = declaration.getInitializer();
-        if (init !== void 0 && (import_ts_morph63.Node.isArrowFunction(init) || import_ts_morph63.Node.isFunctionExpression(init)) && hasBody(init)) {
+        if (init !== void 0 && (import_ts_morph64.Node.isArrowFunction(init) || import_ts_morph64.Node.isFunctionExpression(init)) && hasBody(init)) {
           roots.push({ func: init, name: declaration.getName() });
         }
       }
@@ -14569,7 +14524,7 @@ function recognizerOnlyRoots(packsByFile) {
 }
 function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS, alreadySummarized = [], extraRoots = []) {
   const lookup = createSourceFileLookup(project);
-  const db = facts?.db ?? new import_datalog4.Database();
+  const db = facts?.db ?? new import_datalog3.Database();
   const functionByKey = /* @__PURE__ */ new Map();
   const seedKeys = /* @__PURE__ */ new Set();
   const scanned = /* @__PURE__ */ new Set();
@@ -14608,7 +14563,7 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
     }
   }
   for (; ; ) {
-    (0, import_datalog4.evaluate)(db, REACHABLE_RULES);
+    (0, import_datalog3.evaluate)(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
     if (frontier.length === 0) {
       break;
@@ -14813,21 +14768,21 @@ function recordParameterGaps(parameterCallsByKey, summariesByKey, passedPosition
 }
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph64 = require("ts-morph");
-var import_datalog5 = require("@suss/datalog");
+var import_ts_morph65 = require("ts-morph");
+var import_datalog4 = require("@suss/datalog");
 var RETHROW_RULES = [
-  (0, import_datalog5.rule)(
+  (0, import_datalog4.rule)(
     "contributes",
-    [(0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s")],
-    [(0, import_datalog5.lit)("throwsDirect", (0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s"))]
+    [(0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s")],
+    [(0, import_datalog4.lit)("throwsDirect", (0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog4.rule)(
     "contributes",
-    [(0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("s")],
+    [(0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("s")],
     [
-      (0, import_datalog5.lit)("rethrowSite", (0, import_datalog5.variable)("u"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("siteCalls", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("contributes", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("s"))
+      (0, import_datalog4.lit)("rethrowSite", (0, import_datalog4.variable)("u"), (0, import_datalog4.variable)("site")),
+      (0, import_datalog4.lit)("siteCalls", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("contributes", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("s"))
     ]
   )
 ];
@@ -14839,7 +14794,7 @@ function enrichRethrows(summaries, project, facts) {
     summary.location.range.start,
     summary.location.range.end
   ));
-  const db = facts?.db ?? new import_datalog5.Database();
+  const db = facts?.db ?? new import_datalog4.Database();
   const sourceById = /* @__PURE__ */ new Map();
   const nameByUnit = /* @__PURE__ */ new Map();
   const targets = [];
@@ -14889,7 +14844,7 @@ function enrichRethrows(summaries, project, facts) {
       }
     }
   }
-  (0, import_datalog5.evaluate)(db, RETHROW_RULES);
+  (0, import_datalog4.evaluate)(db, RETHROW_RULES);
   const contributesByUnit = /* @__PURE__ */ new Map();
   for (const [unit, sourceId] of db.facts("contributes")) {
     const bucket = contributesByUnit.get(String(unit));
@@ -14950,7 +14905,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph64.Node.isThrowStatement(node)) {
+    if (!import_ts_morph65.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -14960,7 +14915,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph64.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph65.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -14970,13 +14925,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph64.Node.isCatchClause(current2)) {
+    if (import_ts_morph65.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph64.Node.isTryStatement(current2)) {
+    if (import_ts_morph65.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph64.Node.isFunctionDeclaration(current2) || import_ts_morph64.Node.isFunctionExpression(current2) || import_ts_morph64.Node.isArrowFunction(current2) || import_ts_morph64.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph65.Node.isFunctionDeclaration(current2) || import_ts_morph65.Node.isFunctionExpression(current2) || import_ts_morph65.Node.isArrowFunction(current2) || import_ts_morph65.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -14984,14 +14939,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph64.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph65.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph64.Node.isCallExpression(node)) {
+    if (!import_ts_morph65.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -15008,7 +14963,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph64.Node.isCallExpression(call)) {
+  if (!import_ts_morph65.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -15038,12 +14993,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph64.Node.isFunctionDeclaration(decl) || import_ts_morph64.Node.isFunctionExpression(decl) || import_ts_morph64.Node.isArrowFunction(decl) || import_ts_morph64.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph65.Node.isFunctionDeclaration(decl) || import_ts_morph65.Node.isFunctionExpression(decl) || import_ts_morph65.Node.isArrowFunction(decl) || import_ts_morph65.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph64.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph65.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph64.Node.isArrowFunction(init) || import_ts_morph64.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph65.Node.isArrowFunction(init) || import_ts_morph65.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -15051,22 +15006,22 @@ function functionFromDecl(decl) {
 }
 // src/shapes/fieldAccesses.ts
-var import_ts_morph65 = require("ts-morph");
+var import_ts_morph66 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph65.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph66.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph65.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph66.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph65.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph66.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph65.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph66.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -15087,11 +15042,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph65.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph66.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph65.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph66.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -15123,7 +15078,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph65.Node.isCallExpression(node)) {
+  if (import_ts_morph66.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -15155,14 +15110,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph65.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph66.Node.isParameterDeclaration(decl)) {
     return null;
   }
   const base = prefixOfThenParam(decl, responseCall, depth + 1);
   return base === null ? null : [...base, ...chain.segments];
 }
 function firstCallbackParamName(callback) {
-  if (callback === void 0 || !(import_ts_morph65.Node.isArrowFunction(callback) || import_ts_morph65.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph66.Node.isArrowFunction(callback) || import_ts_morph66.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -15170,11 +15125,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph65.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph66.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap(expr) {
   let node = expr;
-  while (import_ts_morph65.Node.isAwaitExpression(node) || import_ts_morph65.Node.isParenthesizedExpression(node) || import_ts_morph65.Node.isAsExpression(node)) {
+  while (import_ts_morph66.Node.isAwaitExpression(node) || import_ts_morph66.Node.isParenthesizedExpression(node) || import_ts_morph66.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -15184,15 +15139,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph65.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph66.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph65.Node.isExpression(expr) ? unwrap(expr) : expr;
-  if (import_ts_morph65.Node.isCallExpression(node)) {
+  let node = import_ts_morph66.Node.isExpression(expr) ? unwrap(expr) : expr;
+  if (import_ts_morph66.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph65.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph66.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -15211,16 +15166,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph65.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph66.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph66.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph65.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph66.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -15231,7 +15186,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph65.Node.isIdentifier(node)) {
+    if (!import_ts_morph66.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -15243,13 +15198,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph65.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph66.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph65.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph66.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -15263,15 +15218,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph65.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph66.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph65.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph66.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph65.Node.isFunctionLikeDeclaration(current2) || import_ts_morph65.Node.isVariableStatement(current2)) {
+    if (import_ts_morph66.Node.isFunctionLikeDeclaration(current2) || import_ts_morph66.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -15334,7 +15289,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph65.Node.isIfStatement(parent)) {
+    if (import_ts_morph66.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -15396,7 +15351,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 // src/subUnitContext.ts
-var import_ts_morph66 = require("ts-morph");
+var import_ts_morph67 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -15423,18 +15378,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph66.Node.isJsxOpeningElement(node) && !import_ts_morph66.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph67.Node.isJsxOpeningElement(node) && !import_ts_morph67.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph66.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph67.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph66.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph67.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -15457,11 +15412,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph66.Node.isCallExpression(node)) {
+    if (!import_ts_morph67.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph66.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph67.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -15472,10 +15427,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrowFunction(expr) || import_ts_morph66.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph67.Node.isArrowFunction(expr) || import_ts_morph67.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph66.Node.isIdentifier(expr)) {
+  if (import_ts_morph67.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -15494,15 +15449,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph66.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph67.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph66.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph67.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph66.Node.isArrowFunction(init) || import_ts_morph66.Node.isFunctionExpression(init)) {
+    if (import_ts_morph67.Node.isArrowFunction(init) || import_ts_morph67.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -15523,7 +15478,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrowFunction(arg) || import_ts_morph66.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph67.Node.isArrowFunction(arg) || import_ts_morph67.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -15535,7 +15490,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph66.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph67.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -15586,14 +15541,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 +15716,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(
@@ -15784,13 +15739,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph67.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph68.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph67.Node.isOmittedExpression(element)) {
+      if (import_ts_morph68.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -15820,7 +15775,7 @@ function objectParamInputs(param, position, mapping) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -15850,7 +15805,7 @@ function bindingRole(element, name) {
   if (property === void 0) {
     return name;
   }
-  if (import_ts_morph67.Node.isStringLiteral(property)) {
+  if (import_ts_morph68.Node.isStringLiteral(property)) {
     return property.getLiteralValue();
   }
   return property.getText();
@@ -15882,7 +15837,7 @@ function extractParameters(func, inputMapping) {
       const param = params[i];
       const nameNode = param.getNameNode();
       const boundNames = bindingPatternNames(nameNode);
-      if (import_ts_morph67.Node.isObjectBindingPattern(nameNode)) {
+      if (import_ts_morph68.Node.isObjectBindingPattern(nameNode)) {
         for (const element of nameNode.getElements()) {
           result.push({
             name: element.getName(),
@@ -15949,7 +15904,7 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph67.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph68.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -15958,19 +15913,19 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph67.Node.isAwaitExpression(init)) {
+    if (import_ts_morph68.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph67.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph68.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph67.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph68.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph67.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph68.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -16329,6 +16284,10 @@ function extractBindingPath(binding, callSite, pack, resolution) {
     const arg = callSite.callExpression.getArguments()[p.position];
     return arg === void 0 ? void 0 : pathFromArgument(arg, resolution);
   }
+  if (p.type === "fromArgumentProperty") {
+    const arg = callSite.callExpression.getArguments()[p.position];
+    return arg === void 0 ? void 0 : pathFromProperty(arg, p.property, resolution);
+  }
   return void 0;
 }
 function resolveContractField(callSite, pack, field, resolution) {
@@ -16407,7 +16366,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 +16428,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 +16638,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));
@@ -16724,20 +16683,23 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
   return summaries;
 }
 function stampWrappers(raw, unit, wrappers) {
-  if (wrappers === void 0 || unit.registrationSubjectId === void 0) {
-    return;
-  }
-  const applied = wrappers.wrappersFor(unit.registrationSubjectId);
+  const applied = [
+    ...wrappers === void 0 || unit.registrationSubjectId === void 0 ? [] : wrappers.wrappersFor(unit.registrationSubjectId),
+    ...unit.routeWrappers ?? []
+  ];
   if (applied.length === 0) {
     return;
   }
-  raw.wrappers = [...applied];
+  raw.wrappers = applied;
   for (const wrapper of applied) {
     recordFileDependency(wrapper.file);
   }
 }
 function unfollowedStopsOf(unit, wrappers) {
-  const stops = unit.unfollowed === void 0 ? [] : [unit.unfollowed];
+  const stops = [
+    ...unit.unfollowed === void 0 ? [] : [unit.unfollowed],
+    ...unit.routeUnfollowed ?? []
+  ];
   if (wrappers === void 0 || unit.registrationSubjectId === void 0) {
     return stops;
   }
@@ -16884,9 +16846,9 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(import_ts_morph67.SyntaxKind.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(import_ts_morph68.SyntaxKind.CallExpression)) {
     const first = call.getArguments()[0];
-    if (first === void 0 || !import_ts_morph67.Node.isIdentifier(first)) {
+    if (first === void 0 || !import_ts_morph68.Node.isIdentifier(first)) {
       continue;
     }
     const at = names.indexOf(first.getText());
@@ -16935,16 +16897,16 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph68.Node.isFunctionDeclaration(func) || import_ts_morph68.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph67.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph68.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph68.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph68.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -16953,10 +16915,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph67.Node.isCallExpression(current2)) {
+    if (import_ts_morph68.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph67.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph68.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -16967,7 +16929,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph67.Node.isFunctionDeclaration(current2) || import_ts_morph67.Node.isFunctionExpression(current2) || import_ts_morph67.Node.isArrowFunction(current2) || import_ts_morph67.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph68.Node.isFunctionDeclaration(current2) || import_ts_morph68.Node.isFunctionExpression(current2) || import_ts_morph68.Node.isArrowFunction(current2) || import_ts_morph68.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -16975,13 +16937,13 @@ function enclosingFunction(node) {
   return null;
 }
 function callerName(func) {
-  if (import_ts_morph67.Node.isFunctionDeclaration(func) || import_ts_morph67.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph68.Node.isFunctionDeclaration(func) || import_ts_morph68.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph67.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph68.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph67.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph68.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -17022,7 +16984,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 +16996,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
@@ -17080,7 +17042,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? import_node_path11.default.dirname(suppliedConfig.tsConfigFilePath) : void 0)
     )
   };
-  const project = config.project ?? new import_ts_morph67.Project(
+  const project = config.project ?? new import_ts_morph68.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -17092,7 +17054,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 }
@@ -17127,11 +17089,15 @@ function createTypeScriptAdapter(suppliedConfig) {
           )
         );
       }
-      return named(summaries, config.workspace, runRoot);
+      return named(
+        (0, import_extractor12.composeWrappers)(summaries, config.extractorOptions ?? {}),
+        config.workspace,
+        runRoot
+      );
     },
     async extractAll() {
-      const timer = (0, import_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 +17110,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
@@ -17338,7 +17304,7 @@ function createTypeScriptAdapter(suppliedConfig) {
         )
       );
       const closureFacts = {
-        db: new import_datalog6.Database(),
+        db: new import_datalog5.Database(),
         unitKeyBySummary: /* @__PURE__ */ new Map(),
         ...caching ? { filesByKey: /* @__PURE__ */ new Map() } : {}
       };
@@ -17387,15 +17353,9 @@ function createTypeScriptAdapter(suppliedConfig) {
         "enrichRethrows",
         () => enrichRethrows(merged.summaries, project, closureFacts)
       );
-      if (config.includeReachable !== false) {
-        timer.time(
-          "deriveBoundaryEffects",
-          () => deriveBoundaryEffects(enriched, closureFacts)
-        );
-      }
       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 +17417,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 +17431,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 +17443,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 +17742,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 ?? {},
@@ -17796,7 +17756,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path12 = __toESM(require("path"), 1);
-var import_ts_morph68 = require("ts-morph");
+var import_ts_morph69 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -17844,12 +17804,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph68.Project({
+  const project = new import_ts_morph69.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph68.ScriptTarget.ES2022,
-      module: import_ts_morph68.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph68.ModuleResolutionKind.Bundler,
+      target: import_ts_morph69.ScriptTarget.ES2022,
+      module: import_ts_morph69.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph69.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -17871,10 +17831,18 @@ function createProjectWithoutTsconfig(rootDir) {
   }
   return { project, files };
 }
+var TSCONFIG_NAMES = [
+  "tsconfig.json",
+  "jsconfig.json",
+  "tsconfig.base.json"
+];
+var WALK_UP_TSCONFIG_NAMES = ["tsconfig.json", "jsconfig.json"];
 function findNearestTsconfig(startDir) {
-  let dir = import_node_path12.default.resolve(startDir);
+  const start = import_node_path12.default.resolve(startDir);
+  let dir = start;
   while (true) {
-    for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const names = dir === start ? TSCONFIG_NAMES : WALK_UP_TSCONFIG_NAMES;
+    for (const name of names) {
       const candidate = import_node_path12.default.join(dir, name);
       if (import_node_fs5.default.existsSync(candidate)) {
         return candidate;
@@ -17890,7 +17858,7 @@ function findNearestTsconfig(startDir) {
 // src/facts/why.ts
 var import_node_path13 = __toESM(require("path"), 1);
-var import_ts_morph69 = require("ts-morph");
+var import_ts_morph70 = require("ts-morph");
 var import_resolution7 = require("@suss/resolution");
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -17904,7 +17872,7 @@ var TypeScriptWhySession = class {
   constructor(options) {
     this.root = import_node_path13.default.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
-    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph69.Project({ tsConfigFilePath: tsconfig });
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph70.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
   }
   /**
@@ -17919,7 +17887,7 @@ var TypeScriptWhySession = class {
     }
     let found = null;
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph69.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+      if (import_ts_morph70.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
         found = node;
       }
     });
@@ -17937,7 +17905,7 @@ var TypeScriptWhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      import_ts_morph69.SyntaxKind.CallExpression
+      import_ts_morph70.SyntaxKind.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -18011,21 +17979,21 @@ var TypeScriptWhySession = class {
   }
 };
 function displayNameOf(node) {
-  if (import_ts_morph69.Node.isIdentifier(node) || import_ts_morph69.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph70.Node.isIdentifier(node) || import_ts_morph70.Node.isPropertyAccessExpression(node)) {
     return node.getText();
   }
-  if (import_ts_morph69.Node.isCallExpression(node) || import_ts_morph69.Node.isNewExpression(node)) {
+  if (import_ts_morph70.Node.isCallExpression(node) || import_ts_morph70.Node.isNewExpression(node)) {
     return `${node.getExpression()?.getText() ?? "call"}(...)`;
   }
-  if (import_ts_morph69.Node.isFunctionDeclaration(node) || import_ts_morph69.Node.isClassDeclaration(node) || import_ts_morph69.Node.isMethodDeclaration(node) || import_ts_morph69.Node.isVariableDeclaration(node)) {
+  if (import_ts_morph70.Node.isFunctionDeclaration(node) || import_ts_morph70.Node.isClassDeclaration(node) || import_ts_morph70.Node.isMethodDeclaration(node) || import_ts_morph70.Node.isVariableDeclaration(node)) {
     const name = node.getName();
     if (name !== void 0) {
       return name;
     }
   }
-  if (import_ts_morph69.Node.isArrowFunction(node) || import_ts_morph69.Node.isFunctionExpression(node)) {
+  if (import_ts_morph70.Node.isArrowFunction(node) || import_ts_morph70.Node.isFunctionExpression(node)) {
     const parent = node.getParent();
-    if (parent !== void 0 && import_ts_morph69.Node.isVariableDeclaration(parent)) {
+    if (parent !== void 0 && import_ts_morph70.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
   }
@@ -18035,7 +18003,7 @@ function displayNameOf(node) {
 // src/stubEvidence.ts
 var import_node_path14 = __toESM(require("path"), 1);
-var import_ts_morph70 = require("ts-morph");
+var import_ts_morph71 = require("ts-morph");
 function stubEvidenceIn(project, packageName, root) {
   const resolution = new ResolutionStore();
   const byExport = /* @__PURE__ */ new Map();
@@ -18062,7 +18030,7 @@ function stubEvidenceIn(project, packageName, root) {
   );
 }
 function stubEvidence(options) {
-  const project = new import_ts_morph70.Project(
+  const project = new import_ts_morph71.Project(
     options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : { compilerOptions: { allowJs: true } }
   );
   const root = options.tsConfigFilePath !== void 0 ? import_node_path14.default.dirname(options.tsConfigFilePath) : import_node_path14.default.resolve(options.directory ?? process.cwd());
@@ -18080,6 +18048,7 @@ function stubEvidence(options) {
   GENERIC_TERMINALS,
   NO_BARRIERS,
   ResolutionStore,
+  TSCONFIG_NAMES,
   TypeScriptWhySession,
   accessContextFor,
   buildProjectHelperIndex,