@suss/adapter-typescript 0.22.2 → 0.22.4

package/dist/index.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ADAPTER_VERSION: () => ADAPTER_VERSION,
+  GENERIC_TERMINALS: () => GENERIC_TERMINALS,
+  NO_BARRIERS: () => NO_BARRIERS,
   ResolutionStore: () => ResolutionStore,
   TypeScriptWhySession: () => TypeScriptWhySession,
   accessContextFor: () => accessContextFor,
@@ -51,6 +53,7 @@ __export(index_exports, {
   findNearestTsconfig: () => findNearestTsconfig,
   findTerminals: () => findTerminals,
   functionTargetOf: () => functionTargetOf,
+  hasBody: () => hasBody,
   importDeclarationsOf: () => importDeclarationsOf,
   importedNamesOf: () => importedNamesOf,
   importedRootsOf: () => importedRootsOf,
@@ -66,6 +69,7 @@ __export(index_exports, {
   resolveAliasedSymbol: () => resolveAliasedSymbol,
   resolveSubject: () => resolveSubject,
   rootIdentifier: () => rootIdentifier,
+  startsItsOwnScope: () => startsItsOwnScope,
   stubEvidence: () => stubEvidence,
   stubEvidenceIn: () => stubEvidenceIn,
   workspaceRootFor: () => workspaceRootFor
@@ -3732,6 +3736,18 @@ var ResolutionStore = class {
     const target = factKeyOf(value);
     return this.askAbout(target, "wanted", () => this.lookupObject(target));
   }
+  /**
+   * The function a call returns: `app.use(requireCaller(config))`
+   * registers what the factory gives back. A separate question from
+   * `resolveCallable`, which keeps a call unresolved on purpose so an
+   * unwrapping answer wins; this one is asked only after that has
+   * declined. Two returned functions give null, like every other
+   * single-answer question here.
+   */
+  resolveReturnedCallable(call) {
+    const target = factKeyOf(call);
+    return this.askAbout(target, "wanted", () => this.lookupReturned(target));
+  }
   /**
    * For a value that is neither a function nor an object, such as a
    * GraphQL document kept in a constant in another file.
@@ -4175,6 +4191,21 @@ var ResolutionStore = class {
     }
     return [...candidates][0];
   }
+  lookupReturned(call) {
+    this.derive();
+    const candidates = /* @__PURE__ */ new Set();
+    for (const target of this.answersFor("wantedGivesBack", nodeId(call))) {
+      const node = this.table.byId.get(target);
+      if (node === void 0 || !isFunctionRoot(node)) {
+        continue;
+      }
+      candidates.add(node);
+    }
+    if (candidates.size !== 1) {
+      return null;
+    }
+    return [...candidates][0];
+  }
   /**
    * Two candidates give null, since ambiguity is nothing. The value
    * itself is never a result either, or an identifier whose chain went
@@ -4658,6 +4689,26 @@ function resolveImportedLocalName(sourceFile, importModule, importName) {
   }
   return null;
 }
+function importedReferenceSpellings(sourceFile, importModule, importName) {
+  const spellings = [];
+  const localName = resolveImportedLocalName(
+    sourceFile,
+    importModule,
+    importName
+  );
+  if (localName !== null) {
+    spellings.push(localName);
+  }
+  if (!sourceFile.getFullText().includes(`.${importName}`)) {
+    return spellings;
+  }
+  for (const root of importedRootsOf(sourceFile, [importModule])) {
+    if (root !== importName) {
+      spellings.push(`${root}.${importName}`);
+    }
+  }
+  return spellings;
+}
 
 // src/discovery/resolveValue.ts
 var import_ts_morph19 = require("ts-morph");
@@ -5262,7 +5313,27 @@ function functionValueOf(value, resolution) {
     return null;
   }
   const resolved = resolution.resolveCallable(written);
-  return resolved === null ? null : toFunctionRoot(resolved);
+  if (resolved !== null) {
+    return toFunctionRoot(resolved);
+  }
+  if (!import_ts_morph19.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)) {
+    return property.getName();
+  }
+  return null;
+}
+function propertyFunctionOf(property, resolution) {
+  if (import_ts_morph19.Node.isMethodDeclaration(property)) {
+    return property;
+  }
+  const held = propertyValueOf(property);
+  return held === null ? null : functionValueOf(held, resolution);
 }
 function objectLiteralOf(value, resolution) {
   return literalValueOf(
@@ -8081,13 +8152,13 @@ function collectMethodsCalledOnCallResults(sourceFile) {
   return called;
 }
 function registrationSubjectsOf(sourceFile, importModule, importName, resolution) {
-  const importedLocalName = resolveImportedLocalName(
+  const spellings = importedReferenceSpellings(
     sourceFile,
     importModule,
     importName
   );
   const subjects = /* @__PURE__ */ new Map();
-  if (importedLocalName === null) {
+  if (spellings.length === 0) {
     return subjects;
   }
   sourceFile.forEachDescendant((node) => {
@@ -8097,7 +8168,7 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
         return;
       }
       const calleeText = import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init) ? init.getExpression().getText() : null;
-      if (calleeText === importedLocalName) {
+      if (calleeText !== null && spellings.includes(calleeText)) {
         subjects.set(node.getName(), init);
       }
       return;
@@ -8110,7 +8181,9 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
       return;
     }
     const typeText = typeNode.getText();
-    if (typeText === importedLocalName || typeText.startsWith(`${importedLocalName}<`)) {
+    if (spellings.some(
+      (spelling) => typeText === spelling || typeText.startsWith(`${spelling}<`)
+    )) {
       subjects.set(node.getName(), creationSiteBehind(node, resolution));
     }
   });
@@ -8154,17 +8227,17 @@ function registrationSubjectIdsOf(sourceFile, matches, resolution) {
   return ids;
 }
 function unboundConstructionsOf(sourceFile, importModule, importName) {
-  const importedLocalName = resolveImportedLocalName(
+  const spellings = importedReferenceSpellings(
     sourceFile,
     importModule,
     importName
   );
-  if (importedLocalName === null) {
+  if (spellings.length === 0) {
     return [];
   }
   const constructions = [];
   sourceFile.forEachDescendant((node) => {
-    if ((import_ts_morph34.Node.isCallExpression(node) || import_ts_morph34.Node.isNewExpression(node)) && node.getExpression().getText() === importedLocalName && !import_ts_morph34.Node.isVariableDeclaration(node.getParent())) {
+    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())) {
       constructions.push(node);
     }
   });
@@ -8720,7 +8793,7 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
     }
     const schemaSdl = extractTypeDefsSdl(config, store);
     for (const typeProp of propertiesOf(resolversObj, store)) {
-      const typeName = resolverPropertyName(typeProp);
+      const typeName = propertyNameOf(typeProp);
       if (typeName === null || excludeTypes.has(typeName)) {
         continue;
       }
@@ -8729,11 +8802,11 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
         continue;
       }
       for (const fieldProp of propertiesOf(typeObj, store)) {
-        const fieldName = resolverPropertyName(fieldProp);
+        const fieldName = propertyNameOf(fieldProp);
         if (fieldName === null) {
           continue;
         }
-        const fn = resolverPropertyFunction(fieldProp, store);
+        const fn = propertyFunctionOf(fieldProp, store);
         if (fn === null) {
           continue;
         }
@@ -8797,22 +8870,6 @@ function writtenSdl(expr) {
   }
   return null;
 }
-function resolverPropertyName(prop) {
-  if (import_ts_morph38.Node.isPropertyAssignment(prop) || import_ts_morph38.Node.isMethodDeclaration(prop)) {
-    return prop.getName();
-  }
-  if (import_ts_morph38.Node.isShorthandPropertyAssignment(prop)) {
-    return prop.getName();
-  }
-  return null;
-}
-function resolverPropertyFunction(prop, resolution) {
-  if (import_ts_morph38.Node.isMethodDeclaration(prop)) {
-    return prop;
-  }
-  const held = propertyValueOf(prop);
-  return held === null ? null : functionValueOf(held, resolution);
-}
 
 // src/discovery/index.ts
 function runPattern(sourceFile, pattern, resolution, mountPrefixes, expandedElsewhere) {
@@ -10195,199 +10252,12 @@ function tryMatchParameterCall(node, func, pattern, match) {
   return { node, terminal };
 }
 
-// src/terminals/jsx.ts
-var import_ts_morph46 = require("ts-morph");
-function tryMatchJsxReturn(node, pattern) {
-  let expr;
-  let source;
-  if (import_ts_morph46.Node.isReturnStatement(node)) {
-    expr = node.getExpression();
-    source = node;
-  } else if (import_ts_morph46.Node.isArrowFunction(node)) {
-    const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph46.Node.isBlock(body)) {
-      expr = body;
-      source = body;
-    }
-  }
-  if (expr === void 0 || source === void 0) {
-    return null;
-  }
-  const tree = jsxToRenderNode(expr);
-  if (tree === null) {
-    return null;
-  }
-  const component = tree.type === "element" ? tree.tag : "Fragment";
-  const terminal = {
-    kind: pattern.kind,
-    statusCode: null,
-    body: null,
-    exceptionType: null,
-    message: null,
-    component,
-    delegateTarget: null,
-    emitEvent: null,
-    renderTree: tree,
-    location: {
-      start: startLineOf(node),
-      end: endLineOf(node)
-    }
-  };
-  return { node, source, terminal };
-}
-function componentTargetOf(tagNode) {
-  if (!import_ts_morph46.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
-    return null;
-  }
-  const target = functionTargetOf(tagNode);
-  return target === null ? null : { file: target.file, name: target.name };
-}
-function jsxToRenderNode(node) {
-  if (import_ts_morph46.Node.isJsxElement(node)) {
-    const opening = node.getOpeningElement();
-    const tag = opening.getTagNameNode().getText();
-    const attrs = collectJsxAttributes(opening);
-    const target = componentTargetOf(opening.getTagNameNode());
-    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
-    return {
-      type: "element",
-      tag,
-      children,
-      ...attrs !== null ? { attrs } : {},
-      ...target !== null ? { target } : {}
-    };
-  }
-  if (import_ts_morph46.Node.isJsxSelfClosingElement(node)) {
-    const tag = node.getTagNameNode().getText();
-    const attrs = collectJsxAttributes(node);
-    const target = componentTargetOf(node.getTagNameNode());
-    return {
-      type: "element",
-      tag,
-      children: [],
-      ...attrs !== null ? { attrs } : {},
-      ...target !== null ? { target } : {}
-    };
-  }
-  if (import_ts_morph46.Node.isJsxFragment(node)) {
-    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
-    return { type: "element", tag: "Fragment", children };
-  }
-  if (import_ts_morph46.Node.isParenthesizedExpression(node)) {
-    return jsxToRenderNode(node.getExpression());
-  }
-  return null;
-}
-function collectJsxAttributes(opening) {
-  const entries = {};
-  for (const attr of opening.getAttributes()) {
-    if (import_ts_morph46.Node.isJsxSpreadAttribute(attr)) {
-      const exprText = attr.getExpression().getText();
-      entries[`...${exprText}`] = exprText;
-      continue;
-    }
-    if (!import_ts_morph46.Node.isJsxAttribute(attr)) {
-      continue;
-    }
-    const name = attr.getNameNode().getText();
-    const initializer = attr.getInitializer();
-    if (initializer === void 0) {
-      entries[name] = "";
-      continue;
-    }
-    if (import_ts_morph46.Node.isJsxExpression(initializer)) {
-      const inner = initializer.getExpression();
-      entries[name] = inner !== void 0 ? inner.getText() : "";
-      continue;
-    }
-    entries[name] = initializer.getText();
-  }
-  return Object.keys(entries).length > 0 ? entries : null;
-}
-function jsxChildToRenderNode(child) {
-  if (import_ts_morph46.Node.isJsxText(child)) {
-    const text = child.getLiteralText().trim();
-    if (text.length === 0) {
-      return null;
-    }
-    return { type: "text", value: text };
-  }
-  if (import_ts_morph46.Node.isJsxExpression(child)) {
-    const inner = child.getExpression();
-    if (inner === void 0) {
-      return null;
-    }
-    return jsxExpressionToRenderNode(inner);
-  }
-  if (import_ts_morph46.Node.isJsxElement(child) || import_ts_morph46.Node.isJsxSelfClosingElement(child) || import_ts_morph46.Node.isJsxFragment(child)) {
-    return jsxToRenderNode(child);
-  }
-  return null;
-}
-function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph46.Node.isParenthesizedExpression(expr)) {
-    return jsxExpressionToRenderNode(expr.getExpression());
-  }
-  if (import_ts_morph46.Node.isBinaryExpression(expr)) {
-    const op = expr.getOperatorToken().getText();
-    if (op === "&&") {
-      const right = renderAlternative(peelParens(expr.getRight()));
-      if (right.kind === "jsx") {
-        return {
-          type: "conditional",
-          condition: expr.getLeft().getText(),
-          whenTrue: right.node,
-          whenFalse: null
-        };
-      }
-    }
-  }
-  if (import_ts_morph46.Node.isConditionalExpression(expr)) {
-    const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
-    const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
-    if (truthy.kind === "jsx") {
-      return {
-        type: "conditional",
-        condition: expr.getCondition().getText(),
-        whenTrue: truthy.node,
-        whenFalse: falsy.kind === "jsx" ? falsy.node : null
-      };
-    }
-    if (falsy.kind === "jsx") {
-      return {
-        type: "conditional",
-        condition: `!(${expr.getCondition().getText()})`,
-        whenTrue: falsy.node,
-        whenFalse: null
-      };
-    }
-  }
-  return { type: "expression", sourceText: expr.getText() };
-}
-function renderAlternative(node) {
-  if (import_ts_morph46.Node.isNullLiteral(node)) {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isFalseLiteral(node)) {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isIdentifier(node) && node.getText() === "undefined") {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isJsxElement(node) || import_ts_morph46.Node.isJsxSelfClosingElement(node) || import_ts_morph46.Node.isJsxFragment(node)) {
-    const tree = jsxToRenderNode(node);
-    if (tree !== null) {
-      return { kind: "jsx", node: tree };
-    }
-  }
-  return { kind: "notStatic" };
-}
-
-// src/terminals/returns.ts
-var import_ts_morph51 = require("ts-morph");
+// src/terminals/extract.ts
+var import_ts_morph47 = require("ts-morph");
+var import_values5 = require("@suss/values");
 
 // src/shapes/shapes.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph46 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
@@ -10846,60 +10716,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph47.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph46.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph47.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isStringLiteral(unwrapped2) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isStringLiteral(unwrapped2) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph47.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph47.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph47.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph47.SyntaxKind.MinusToken || op === import_ts_morph47.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph46.SyntaxKind.MinusToken || op === import_ts_morph46.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph47.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph46.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph47.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph46.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph47.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph46.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph47.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph47.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph47.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph47.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph47.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph46.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph47.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -10930,7 +10800,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph47.Node.isSpreadElement(el)) {
+    if (import_ts_morph46.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -10949,7 +10819,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph47.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isPropertyAssignment(prop)) {
       const name = propertyName2(prop);
       if (name === null) {
         continue;
@@ -10965,7 +10835,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -10974,7 +10844,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph46.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -10993,7 +10863,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName2(prop) {
   const nameNode = prop.getNameNode();
-  if (import_ts_morph47.Node.isIdentifier(nameNode) || import_ts_morph47.Node.isStringLiteral(nameNode) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph47.Node.isNumericLiteral(nameNode)) {
+  if (import_ts_morph46.Node.isIdentifier(nameNode) || import_ts_morph46.Node.isStringLiteral(nameNode) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph46.Node.isNumericLiteral(nameNode)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -11019,22 +10889,20 @@ function collapseVariants2(shapes) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph48 = require("ts-morph");
-var import_values5 = require("@suss/values");
 function unwrapAs(node) {
   return peelSyntax(node);
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph48.Node.isCallExpression(outer)) {
+  if (!import_ts_morph47.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph47.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph48.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph47.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -11044,7 +10912,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph48.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph47.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -11057,10 +10925,10 @@ function extractStatusCode(ctx) {
   if (result !== null) {
     return result;
   }
-  if (ctx.extraction.defaultStatusCode !== void 0) {
-    return { type: "literal", value: ctx.extraction.defaultStatusCode };
-  }
-  return null;
+  return declaredStatusCode(ctx.extraction);
+}
+function declaredStatusCode(extraction) {
+  return extraction.defaultStatusCode !== void 0 ? { type: "literal", value: extraction.defaultStatusCode } : null;
 }
 function matchConstructorCode(ctorText, codes) {
   const fullMatch = codes[ctorText];
@@ -11088,10 +10956,10 @@ function statusFromProperty(obj, name, ctx) {
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -11114,7 +10982,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph48.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph47.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -11127,7 +10995,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph48.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -11136,7 +11004,7 @@ function extractStatusCodeFromRule(ctx) {
   if (sc.from === "argumentProperty") {
     const args = ctx.throwCallArgs ?? ctx.calls?.[0]?.getArguments();
     const arg = args?.[sc.position];
-    if (arg === void 0 || !import_ts_morph48.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -11146,8 +11014,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11205,8 +11073,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -11260,6 +11128,197 @@ function extractBody(ctx) {
   return null;
 }
 
+// src/terminals/jsx.ts
+var import_ts_morph48 = require("ts-morph");
+function tryMatchJsxReturn(node, pattern) {
+  let expr;
+  let source;
+  if (import_ts_morph48.Node.isReturnStatement(node)) {
+    expr = node.getExpression();
+    source = node;
+  } else if (import_ts_morph48.Node.isArrowFunction(node)) {
+    const body = node.getBody();
+    if (body !== void 0 && !import_ts_morph48.Node.isBlock(body)) {
+      expr = body;
+      source = body;
+    }
+  }
+  if (expr === void 0 || source === void 0) {
+    return null;
+  }
+  const tree = jsxToRenderNode(expr);
+  if (tree === null) {
+    return null;
+  }
+  const component = tree.type === "element" ? tree.tag : "Fragment";
+  const terminal = {
+    kind: pattern.kind,
+    statusCode: null,
+    body: null,
+    exceptionType: null,
+    message: null,
+    component,
+    delegateTarget: null,
+    emitEvent: null,
+    renderTree: tree,
+    location: {
+      start: startLineOf(node),
+      end: endLineOf(node)
+    }
+  };
+  return { node, source, terminal };
+}
+function componentTargetOf(tagNode) {
+  if (!import_ts_morph48.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+    return null;
+  }
+  const target = functionTargetOf(tagNode);
+  return target === null ? null : { file: target.file, name: target.name };
+}
+function jsxToRenderNode(node) {
+  if (import_ts_morph48.Node.isJsxElement(node)) {
+    const opening = node.getOpeningElement();
+    const tag = opening.getTagNameNode().getText();
+    const attrs = collectJsxAttributes(opening);
+    const target = componentTargetOf(opening.getTagNameNode());
+    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
+    return {
+      type: "element",
+      tag,
+      children,
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
+    };
+  }
+  if (import_ts_morph48.Node.isJsxSelfClosingElement(node)) {
+    const tag = node.getTagNameNode().getText();
+    const attrs = collectJsxAttributes(node);
+    const target = componentTargetOf(node.getTagNameNode());
+    return {
+      type: "element",
+      tag,
+      children: [],
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
+    };
+  }
+  if (import_ts_morph48.Node.isJsxFragment(node)) {
+    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
+    return { type: "element", tag: "Fragment", children };
+  }
+  if (import_ts_morph48.Node.isParenthesizedExpression(node)) {
+    return jsxToRenderNode(node.getExpression());
+  }
+  return null;
+}
+function collectJsxAttributes(opening) {
+  const entries = {};
+  for (const attr of opening.getAttributes()) {
+    if (import_ts_morph48.Node.isJsxSpreadAttribute(attr)) {
+      const exprText = attr.getExpression().getText();
+      entries[`...${exprText}`] = exprText;
+      continue;
+    }
+    if (!import_ts_morph48.Node.isJsxAttribute(attr)) {
+      continue;
+    }
+    const name = attr.getNameNode().getText();
+    const initializer = attr.getInitializer();
+    if (initializer === void 0) {
+      entries[name] = "";
+      continue;
+    }
+    if (import_ts_morph48.Node.isJsxExpression(initializer)) {
+      const inner = initializer.getExpression();
+      entries[name] = inner !== void 0 ? inner.getText() : "";
+      continue;
+    }
+    entries[name] = initializer.getText();
+  }
+  return Object.keys(entries).length > 0 ? entries : null;
+}
+function jsxChildToRenderNode(child) {
+  if (import_ts_morph48.Node.isJsxText(child)) {
+    const text = child.getLiteralText().trim();
+    if (text.length === 0) {
+      return null;
+    }
+    return { type: "text", value: text };
+  }
+  if (import_ts_morph48.Node.isJsxExpression(child)) {
+    const inner = child.getExpression();
+    if (inner === void 0) {
+      return null;
+    }
+    return jsxExpressionToRenderNode(inner);
+  }
+  if (import_ts_morph48.Node.isJsxElement(child) || import_ts_morph48.Node.isJsxSelfClosingElement(child) || import_ts_morph48.Node.isJsxFragment(child)) {
+    return jsxToRenderNode(child);
+  }
+  return null;
+}
+function jsxExpressionToRenderNode(expr) {
+  if (import_ts_morph48.Node.isParenthesizedExpression(expr)) {
+    return jsxExpressionToRenderNode(expr.getExpression());
+  }
+  if (import_ts_morph48.Node.isBinaryExpression(expr)) {
+    const op = expr.getOperatorToken().getText();
+    if (op === "&&") {
+      const right = renderAlternative(peelParens(expr.getRight()));
+      if (right.kind === "jsx") {
+        return {
+          type: "conditional",
+          condition: expr.getLeft().getText(),
+          whenTrue: right.node,
+          whenFalse: null
+        };
+      }
+    }
+  }
+  if (import_ts_morph48.Node.isConditionalExpression(expr)) {
+    const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
+    const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
+    if (truthy.kind === "jsx") {
+      return {
+        type: "conditional",
+        condition: expr.getCondition().getText(),
+        whenTrue: truthy.node,
+        whenFalse: falsy.kind === "jsx" ? falsy.node : null
+      };
+    }
+    if (falsy.kind === "jsx") {
+      return {
+        type: "conditional",
+        condition: `!(${expr.getCondition().getText()})`,
+        whenTrue: falsy.node,
+        whenFalse: null
+      };
+    }
+  }
+  return { type: "expression", sourceText: expr.getText() };
+}
+function renderAlternative(node) {
+  if (import_ts_morph48.Node.isNullLiteral(node)) {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isFalseLiteral(node)) {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isIdentifier(node) && node.getText() === "undefined") {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isJsxElement(node) || import_ts_morph48.Node.isJsxSelfClosingElement(node) || import_ts_morph48.Node.isJsxFragment(node)) {
+    const tree = jsxToRenderNode(node);
+    if (tree !== null) {
+      return { kind: "jsx", node: tree };
+    }
+  }
+  return { kind: "notStatic" };
+}
+
+// src/terminals/returns.ts
+var import_ts_morph51 = require("ts-morph");
+
 // src/terminals/helperResolution.ts
 var import_ts_morph49 = require("ts-morph");
 function resolveHelperReturn(call, resolveCallee2) {
@@ -11831,10 +11890,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   return null;
 }
 function buildReturnTerminal(locationNode, pattern, body) {
-  const statusCode = pattern.extraction.defaultStatusCode !== void 0 ? { type: "literal", value: pattern.extraction.defaultStatusCode } : null;
   const terminal = {
     kind: pattern.kind,
-    statusCode,
+    statusCode: declaredStatusCode(pattern.extraction),
     body,
     exceptionType: null,
     message: null,
@@ -12123,15 +12181,15 @@ function functionMayFallThrough(func) {
   }
   return true;
 }
-function makeFallthroughTerminal(func) {
+function makeFallthroughTerminal(func, pattern) {
   const body = func.getBody();
   const anchor = body ?? func;
   const line = endLineOf(anchor);
   return {
     node: anchor,
     terminal: {
-      kind: "return",
-      statusCode: null,
+      kind: pattern.kind,
+      statusCode: declaredStatusCode(pattern.extraction),
       body: null,
       exceptionType: null,
       message: null,
@@ -12217,7 +12275,7 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
   });
   return unmatched;
 }
-function extractRawBranches(func, terminalPatterns, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolution, originatesFrom, anchorCallsOf, resolveCallee2) {
+function extractRawBranches(func, terminalPatterns, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolution, originatesFrom, anchorCallsOf, resolveCallee2, collectCallAccounting = false) {
   const terminals = findTerminals(
     func,
     terminalPatterns,
@@ -12251,15 +12309,15 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
     terminals.map(({ node }) => node),
     barriers
   );
-  const wantsFallthrough = terminalPatterns.some(
+  const fallthroughPattern = terminalPatterns.find(
     (p) => p.match.type === "functionFallthrough"
   );
-  if (wantsFallthrough && functionMayFallThrough(func)) {
+  if (fallthroughPattern !== void 0 && functionMayFallThrough(func)) {
     const hasDefaultTerminal = terminals.some(
       ({ node }) => (byTerminal.get(node) ?? []).some(isDefaultConditionList)
     );
     if (!hasDefaultTerminal) {
-      const synthetic = makeFallthroughTerminal(func);
+      const synthetic = makeFallthroughTerminal(func, fallthroughPattern);
       terminals.push(synthetic);
       const pathResult = computePathConditions(
         func,
@@ -12305,8 +12363,8 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
     seenBranches.add(key);
     return true;
   });
+  const terminalNodes = new Set(terminals.map(({ node }) => node));
   if (invocations.length > 0) {
-    const terminalNodes = new Set(terminals.map(({ node }) => node));
     const sideEffects = invocations.filter(
       (i) => !writesTerminal(i.node, terminalNodes)
     );
@@ -12322,7 +12380,39 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
       branch.extraEffects = [...branch.extraEffects ?? [], ...extra];
     }
   }
-  return { branches: distinctBranches, terminals };
+  return {
+    branches: distinctBranches,
+    terminals,
+    ...collectCallAccounting ? {
+      callAccounting: invocations.map(
+        (site) => accountFor(site, terminalNodes, distinctBranches)
+      )
+    } : {}
+  };
+}
+function accountFor(site, terminalNodes, branches) {
+  const { node, line } = site;
+  const callee = node.getExpression().getText();
+  if (writesTerminal(node, terminalNodes)) {
+    return { node, callee, line, outcome: "terminal" };
+  }
+  const call = {
+    line,
+    alwaysRuns: site.alwaysRuns,
+    preconditions: preconditionsOf(site.effect)
+  };
+  if (branches.some((branch) => firesOn(call, branch))) {
+    return { node, callee, line, outcome: "invocation" };
+  }
+  const reachable = branches.some(
+    (branch) => site.alwaysRuns || (0, import_extractor5.runsBefore)(line, branch.terminal.location.end)
+  );
+  return {
+    node,
+    callee,
+    line,
+    outcome: reachable ? "unrecorded" : "unreachable"
+  };
 }
 
 // src/bootstrap/sourceFileLookup.ts
@@ -12537,7 +12627,7 @@ function unwrapContractInit(init) {
   }
   return null;
 }
-function extractEndpointContract(endpointNode, pattern, framework) {
+function extractEndpointContract(endpointNode, pattern, framework, resolution) {
   if (!import_ts_morph56.Node.isObjectLiteralExpression(endpointNode)) {
     return null;
   }
@@ -12562,9 +12652,10 @@ function extractEndpointContract(endpointNode, pattern, framework) {
       }
     }
     if (propName === pattern.responseExtraction.property) {
-      const val = prop.getInitializer();
-      if (val !== void 0 && import_ts_morph56.Node.isObjectLiteralExpression(val)) {
-        for (const respProp of val.getProperties()) {
+      const written = prop.getInitializer();
+      const val = written === void 0 ? null : objectLiteralOf(written, resolution);
+      if (val !== null) {
+        for (const respProp of propertiesOf(val, resolution)) {
           if (!import_ts_morph56.Node.isPropertyAssignment(respProp)) {
             continue;
           }
@@ -12603,7 +12694,12 @@ function readContract(unit, pattern, framework, resolution) {
     if (endpointNode === null) {
       return null;
     }
-    return extractEndpointContract(endpointNode, pattern, framework);
+    return extractEndpointContract(
+      endpointNode,
+      pattern,
+      framework,
+      resolution
+    );
   }
   const routerInfo = findRouterCall(unit);
   if (routerInfo === null) {
@@ -12624,7 +12720,12 @@ function readContract(unit, pattern, framework, resolution) {
     if (endpointInit === void 0) {
       continue;
     }
-    return extractEndpointContract(endpointInit, pattern, framework);
+    return extractEndpointContract(
+      endpointInit,
+      pattern,
+      framework,
+      resolution
+    );
   }
   return null;
 }
@@ -12701,7 +12802,12 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
     if (endpointInit === void 0) {
       continue;
     }
-    return extractEndpointContract(endpointInit, pattern, framework);
+    return extractEndpointContract(
+      endpointInit,
+      pattern,
+      framework,
+      resolution
+    );
   }
   return null;
 }
@@ -13453,7 +13559,11 @@ function recordEdge(edgesByChild, candidate) {
 // src/discovery/wrapperIndex.ts
 var import_ts_morph60 = require("ts-morph");
 var import_resolution6 = require("@suss/resolution");
-var NO_WRAPPERS = { wrappersFor: () => [], unitsIn: () => [] };
+var NO_WRAPPERS = {
+  wrappersFor: () => [],
+  unfollowedFor: () => [],
+  unitsIn: () => []
+};
 var ANONYMOUS = "<anon>";
 function buildWrapperIndex(packsByFile, resolution, mountPrefixes) {
   const workByPack = /* @__PURE__ */ new Map();
@@ -13479,21 +13589,32 @@ function buildWrapperIndex(packsByFile, resolution, mountPrefixes) {
     }
   }
   const bySubject = /* @__PURE__ */ new Map();
+  const unfollowedBySubject = /* @__PURE__ */ new Map();
   const unitsByFile = /* @__PURE__ */ new Map();
+  const stopsSeen = /* @__PURE__ */ new Set();
   let found = false;
   for (const [packName, work] of workByPack) {
     const candidates = [];
     for (const { sourceFile, pattern, match, wraps } of work) {
-      candidates.push(
-        ...discoverWrapperRegistrations(
-          sourceFile,
-          pattern,
-          match,
-          wraps,
-          resolution,
-          mountPrefixes
-        )
+      const scan = discoverWrapperRegistrations(
+        sourceFile,
+        pattern,
+        match,
+        wraps,
+        resolution,
+        mountPrefixes
       );
+      candidates.push(...scan.candidates);
+      for (const { subjectId, callId, stop } of scan.unresolved) {
+        if (stopsSeen.has(callId)) {
+          continue;
+        }
+        stopsSeen.add(callId);
+        found = true;
+        const stops = unfollowedBySubject.get(subjectId) ?? [];
+        stops.push(stop);
+        unfollowedBySubject.set(subjectId, stops);
+      }
     }
     for (const candidate of mostSpecific(candidates)) {
       found = true;
@@ -13511,6 +13632,7 @@ function buildWrapperIndex(packsByFile, resolution, mountPrefixes) {
   }
   return {
     wrappersFor: (subjectId) => bySubject.get(subjectId) ?? [],
+    unfollowedFor: (subjectId) => unfollowedBySubject.get(subjectId) ?? [],
     unitsIn: (file, pack) => unitsByFile.get(unitKey(file, pack)) ?? []
   };
 }
@@ -13544,10 +13666,20 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
     match.importName,
     resolution
   );
+  if ("constructorOption" in wraps) {
+    return discoverConstructorOptions(
+      sourceFile,
+      pattern,
+      wraps,
+      subjects,
+      resolution
+    );
+  }
   if (subjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution)) {
-    return [];
+    return { candidates: [], unresolved: [] };
   }
   const candidates = [];
+  const unresolved = [];
   sourceFile.forEachDescendant((node) => {
     if (!import_ts_morph60.Node.isCallExpression(node)) {
       return;
@@ -13570,8 +13702,13 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
     if (targetArg === void 0) {
       return;
     }
+    const subjectId = nodeId(subjectNode);
     const target = functionValueOf(targetArg, resolution);
     if (target === null) {
+      const stop = factoryStopOf(targetArg);
+      if (stop !== null) {
+        unresolved.push({ subjectId, callId: nodeId(node), stop });
+      }
       return;
     }
     if (wraps.arity !== void 0 && target.getParameters().length !== wraps.arity) {
@@ -13581,29 +13718,136 @@ function discoverWrapperRegistrations(sourceFile, pattern, match, wraps, resolut
     if (scope === null) {
       return;
     }
-    const subjectId = nodeId(subjectNode);
     const mountedScope = scope === void 0 ? void 0 : mountedAt(subjectId, mountPrefixes, scope);
-    const named2 = functionNameOrAnon(target) !== ANONYMOUS;
-    candidates.push({
-      subjectId,
-      callId: nodeId(node),
-      targetId: nodeId(target),
-      byArity: wraps.arity !== void 0,
-      target,
-      pattern,
-      registeredIn: sourceFile.getFilePath(),
-      named: named2,
-      reference: {
-        file: target.getSourceFile().getFilePath(),
-        // A function written out at the registration call has no name
-        // of its own, so it goes by the method that registered it.
-        name: named2 ? functionNameOrAnon(target) : wraps.method,
-        ...wraps.throwParam === void 0 ? {} : { onThrow: true },
-        ...mountedScope === void 0 ? {} : { scope: mountedScope }
-      }
-    });
+    candidates.push(
+      candidateOf(
+        {
+          subjectId,
+          callId: nodeId(node),
+          target,
+          label: labelFor(targetArg, wraps),
+          byArity: wraps.arity !== void 0,
+          onThrow: wraps.throwParam !== void 0,
+          scope: mountedScope
+        },
+        pattern,
+        sourceFile
+      )
+    );
   });
-  return candidates;
+  return { candidates, unresolved };
+}
+function discoverConstructorOptions(sourceFile, pattern, wraps, subjects, resolution) {
+  const candidates = [];
+  const unresolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const construction of subjects.values()) {
+    const subjectId = nodeId(construction);
+    if (seen.has(subjectId) || construction.getSourceFile() !== sourceFile) {
+      continue;
+    }
+    seen.add(subjectId);
+    const option = constructorOptionOf(construction, wraps, resolution);
+    if (option === void 0) {
+      continue;
+    }
+    const callId = nodeId(option);
+    const written = propertyValueOf(option);
+    const target = propertyFunctionOf(option, resolution);
+    if (target === null) {
+      const stop = written === null ? null : factoryStopOf(written);
+      if (stop !== null) {
+        unresolved.push({ subjectId, callId, stop });
+      }
+      continue;
+    }
+    candidates.push(
+      candidateOf(
+        {
+          subjectId,
+          callId,
+          target,
+          label: (written === null ? void 0 : factoryNameOf(written)) ?? wraps.constructorOption,
+          byArity: false,
+          onThrow: wraps.throwParam !== void 0,
+          scope: void 0
+        },
+        pattern,
+        sourceFile
+      )
+    );
+  }
+  return { candidates, unresolved };
+}
+function constructorOptionOf(construction, wraps, resolution) {
+  if (!(import_ts_morph60.Node.isNewExpression(construction) || import_ts_morph60.Node.isCallExpression(construction))) {
+    return void 0;
+  }
+  const optionsArg = construction.getArguments()[wraps.targetPosition];
+  if (optionsArg === void 0) {
+    return void 0;
+  }
+  const options = objectLiteralOf(optionsArg, resolution);
+  if (options === null) {
+    return void 0;
+  }
+  return propertiesOf(options, resolution).find(
+    (property) => propertyNameOf(property) === wraps.constructorOption
+  );
+}
+function candidateOf(registration, pattern, sourceFile) {
+  const { target, label, onThrow, scope } = registration;
+  const named2 = functionNameOrAnon(target) !== ANONYMOUS;
+  return {
+    subjectId: registration.subjectId,
+    callId: registration.callId,
+    targetId: nodeId(target),
+    byArity: registration.byArity,
+    target,
+    pattern,
+    registeredIn: sourceFile.getFilePath(),
+    named: named2,
+    reference: {
+      file: target.getSourceFile().getFilePath(),
+      name: named2 ? functionNameOrAnon(target) : label,
+      ...onThrow ? { onThrow: true } : {},
+      ...scope === void 0 ? {} : { scope }
+    }
+  };
+}
+function labelFor(targetArg, wraps) {
+  return factoryNameOf(targetArg) ?? wraps.method;
+}
+function factoryNameOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph60.Node.isCallExpression(written)) {
+    return void 0;
+  }
+  const callee = written.getExpression();
+  if (import_ts_morph60.Node.isIdentifier(callee)) {
+    return callee.getText();
+  }
+  if (import_ts_morph60.Node.isPropertyAccessExpression(callee)) {
+    return callee.getName();
+  }
+  return void 0;
+}
+function factoryStopOf(targetArg) {
+  const written = factKeyOf(targetArg);
+  if (!import_ts_morph60.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) ?? "";
@@ -13975,22 +14219,23 @@ var import_ts_morph62 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor7 = require("@suss/extractor");
+var GENERIC_TERMINALS = [
+  { kind: "return", match: { type: "returnStatement" }, extraction: {} },
+  { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
+  {
+    // Implicit fall-through at the end of a function body: covers
+    // void-returning orchestrators that never write `return`.
+    kind: "return",
+    match: { type: "functionFallthrough" },
+    extraction: {}
+  }
+];
 var reachablePack = {
   name: "reachable",
   languages: ["typescript"],
   protocol: "in-process",
   discovery: [],
-  terminals: [
-    { kind: "return", match: { type: "returnStatement" }, extraction: {} },
-    { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
-    {
-      // Implicit fall-through at the end of a function body: covers
-      // void-returning orchestrators that never write `return`.
-      kind: "return",
-      match: { type: "functionFallthrough" },
-      extraction: {}
-    }
-  ],
+  terminals: GENERIC_TERMINALS,
   inputMapping: { type: "allPositional" }
 };
 function nodeKey(func) {
@@ -15784,10 +16029,10 @@ var FUNCTION_FALLTHROUGH_TERMINAL = {
   match: { type: "functionFallthrough" },
   extraction: {}
 };
-function thrownValueAt(unit) {
-  return unit.pattern?.wraps?.throwParam;
+function frameworkValueAt(unit) {
+  return unit.pattern?.wraps?.throwParam ?? unit.pattern?.wraps?.resultParam;
 }
-function pastThrownValue(terminals, at) {
+function pastFrameworkValue(terminals, at) {
   if (at === void 0) {
     return terminals;
   }
@@ -15801,7 +16046,7 @@ function pastThrownValue(terminals, at) {
     } : pattern
   );
 }
-function rolesPastThrownValue(mapping, at) {
+function rolesPastFrameworkValue(mapping, at) {
   if (at === void 0 || mapping.type !== "positionalParams") {
     return mapping;
   }
@@ -15827,7 +16072,7 @@ function continuationTerminal(unit) {
 }
 function terminalsFor(unit, pack) {
   const declared = [
-    ...unit.terminals ?? pastThrownValue(pack.terminals, thrownValueAt(unit)),
+    ...unit.terminals ?? pastFrameworkValue(pack.terminals, frameworkValueAt(unit)),
     ...continuationTerminal(unit)
   ];
   if (unit.callSite === void 0) {
@@ -15845,7 +16090,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
   }
   const params = extractParameters(
     func,
-    unit.inputMapping ?? rolesPastThrownValue(pack.inputMapping, thrownValueAt(unit))
+    unit.inputMapping ?? rolesPastFrameworkValue(pack.inputMapping, frameworkValueAt(unit))
   );
   const extracted = extractRawBranches(
     func,
@@ -16347,8 +16592,10 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         }
       }
       const summary = (0, import_extractor11.assembleSummary)(raw, options);
-      if (unit.unfollowed !== void 0 && options?.gapHandling !== "silent") {
-        summary.gaps.push((0, import_behavioral_ir2.unfollowedCallGap)(unit.unfollowed));
+      if (options?.gapHandling !== "silent") {
+        for (const stop of unfollowedStopsOf(unit, wrappers)) {
+          summary.gaps.push((0, import_behavioral_ir2.unfollowedCallGap)(stop));
+        }
       }
       if (unit.metadata !== void 0 && Object.keys(unit.metadata).length > 0) {
         summary.metadata = {
@@ -16401,6 +16648,13 @@ function stampWrappers(raw, unit, wrappers) {
     recordFileDependency(wrapper.file);
   }
 }
+function unfollowedStopsOf(unit, wrappers) {
+  const stops = unit.unfollowed === void 0 ? [] : [unit.unfollowed];
+  if (wrappers === void 0 || unit.registrationSubjectId === void 0) {
+    return stops;
+  }
+  return [...stops, ...wrappers.unfollowedFor(unit.registrationSubjectId)];
+}
 function emitLibraryEnvReadMarkers(summaries, project, frameworks) {
   for (const pack of frameworks) {
     for (const declared of pack.libraryEnvVars ?? []) {
@@ -17115,7 +17369,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       });
       const composed = timer.time(
         "composeWrappers",
-        () => (0, import_extractor11.composeWrappers)(enriched)
+        () => (0, import_extractor11.composeWrappers)(enriched, config.extractorOptions ?? {})
       );
       if (config.onTiming !== void 0) {
         config.onTiming(timer.report());
@@ -17735,6 +17989,8 @@ function stubEvidence(options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ADAPTER_VERSION,
+  GENERIC_TERMINALS,
+  NO_BARRIERS,
   ResolutionStore,
   TypeScriptWhySession,
   accessContextFor,
@@ -17755,6 +18011,7 @@ function stubEvidence(options) {
   findNearestTsconfig,
   findTerminals,
   functionTargetOf,
+  hasBody,
   importDeclarationsOf,
   importedNamesOf,
   importedRootsOf,
@@ -17770,6 +18027,7 @@ function stubEvidence(options) {
   resolveAliasedSymbol,
   resolveSubject,
   rootIdentifier,
+  startsItsOwnScope,
   stubEvidence,
   stubEvidenceIn,
   workspaceRootFor