@suss/adapter-typescript 0.21.1 → 0.22.0

package/dist/index.cjs

@@ -32,26 +32,24 @@ var index_exports = {};
 __export(index_exports, {
   ADAPTER_VERSION: () => ADAPTER_VERSION,
   ResolutionStore: () => ResolutionStore,
-  WhySession: () => WhySession,
+  TypeScriptWhySession: () => TypeScriptWhySession,
   accessContextFor: () => accessContextFor,
   buildProjectHelperIndex: () => buildProjectHelperIndex,
   callOpsFor: () => callOpsFor,
   collectAncestorBranches: () => collectAncestorBranches,
   collectClientFieldAccesses: () => collectClientFieldAccesses,
   computeAdapterPacksDigest: () => computeAdapterPacksDigest,
-  computeContentHash: () => computeContentHash,
+  computeContentHash: () => import_extractor10.computeContentHash,
   createProjectWithoutTsconfig: () => createProjectWithoutTsconfig,
   createTsDiscoveryContext: () => createTsDiscoveryContext,
   createTsSubUnitContext: () => createTsSubUnitContext,
   createTypeScriptAdapter: () => createTypeScriptAdapter,
   discoverUnits: () => discoverUnits,
-  evaluatePackHealth: () => evaluatePackHealth,
   exportedDeclarationsOf: () => exportedDeclarationsOf,
   extractCodeStructure: () => extractCodeStructure,
   extractRawBranches: () => extractRawBranches,
   findNearestTsconfig: () => findNearestTsconfig,
   findTerminals: () => findTerminals,
-  formatPackHealth: () => formatPackHealth,
   functionTargetOf: () => functionTargetOf,
   importDeclarationsOf: () => importDeclarationsOf,
   importedNamesOf: () => importedNamesOf,
@@ -75,15 +73,15 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_ts_morph66 = require("ts-morph");
-var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_behavioral_ir9 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
-var import_extractor7 = require("@suss/extractor");
+var import_extractor11 = require("@suss/extractor");
 
 // src/assembly.ts
 var import_ts_morph54 = require("ts-morph");
-var import_extractor4 = require("@suss/extractor");
+var import_extractor5 = require("@suss/extractor");
 
 // src/conditions.ts
 var import_ts_morph6 = require("ts-morph");
@@ -95,6 +93,7 @@ var import_ts_morph5 = require("ts-morph");
 var import_ts_morph2 = require("ts-morph");
 
 // src/walk/nodeKeys.ts
+var import_behavioral_ir = require("@suss/behavioral-ir");
 function offsetKeyOf(node) {
   return offsetKeyFor(node.getSourceFile().getFilePath(), {
     start: node.getStart(),
@@ -102,7 +101,7 @@ function offsetKeyOf(node) {
   });
 }
 function offsetKeyFor(file, span) {
-  return `${file}:${span.start}-${span.end}`;
+  return (0, import_behavioral_ir.declarationKey)(file, span);
 }
 function lineRangeKey(file, startLine, endLine) {
   return `${file}:${startLine}-${endLine}`;
@@ -1542,7 +1541,7 @@ function degradedResult(func, terminalNodes, reason) {
 
 // src/resolve/invocationEffects.ts
 var import_ts_morph43 = require("ts-morph");
-var import_extractor3 = require("@suss/extractor");
+var import_extractor4 = require("@suss/extractor");
 
 // src/lines.ts
 function startLineOf(node) {
@@ -1910,8 +1909,8 @@ function loadImportGraphsDepthFirstFromPaths(project, rootPaths) {
       stack.pop();
       loadOrder.push(top.path);
       let deepest = 0;
-      for (const path15 of top.deps) {
-        deepest = Math.max(deepest, chainDepth.get(path15) ?? 0);
+      for (const path14 of top.deps) {
+        deepest = Math.max(deepest, chainDepth.get(path14) ?? 0);
       }
       chainDepth.set(top.path, deepest + 1);
     }
@@ -2263,11 +2262,11 @@ function walkAndWarm(root, reach) {
       if (warmedFiles.get(target) !== void 0) {
         continue;
       }
-      const path15 = target.getFilePath();
-      if (visited.has(path15)) {
+      const path14 = target.getFilePath();
+      if (visited.has(path14)) {
         continue;
       }
-      visited.add(path15);
+      visited.add(path14);
       stack.push(frameOf(target, reach));
       continue;
     }
@@ -2284,7 +2283,7 @@ function sitsOnWarmChains(file) {
     return false;
   }
   const imported = importedFilePathsOf(project, file.getFilePath());
-  return imported.length > 0 && imported.every((path15) => warmed.has(path15));
+  return imported.length > 0 && imported.every((path14) => warmed.has(path14));
 }
 function markWarmed(file) {
   warmedFiles.set(file, true);
@@ -2579,6 +2578,32 @@ function writesToBindingUncached(declaration) {
   }
   return { values, inOrder: writesRunInOrder(declaration, writes) };
 }
+function sameConstructionAcrossWrites(values) {
+  const candidates = values.filter((value) => !isNotYetPlaceholder(value));
+  if (candidates.length === 0) {
+    return null;
+  }
+  let construction = null;
+  for (const value of candidates) {
+    if (!isConstruction(value)) {
+      return null;
+    }
+    if (construction !== null && sourceOf(value) !== sourceOf(construction)) {
+      return null;
+    }
+    construction = value;
+  }
+  return construction;
+}
+function isNotYetPlaceholder(value) {
+  return value.getKind() === import_ts_morph14.SyntaxKind.NullKeyword || import_ts_morph14.Node.isIdentifier(value) && value.getText() === "undefined";
+}
+function isConstruction(value) {
+  return import_ts_morph14.Node.isCallExpression(value) || import_ts_morph14.Node.isNewExpression(value);
+}
+function sourceOf(node) {
+  return node.getText().replace(/\s+/g, " ").trim();
+}
 function writesToField(declaration) {
   const remembered = byField.get(declaration);
   if (remembered !== void 0) {
@@ -2669,6 +2694,9 @@ function assignmentsInFile(sourceFile) {
 function isAssignmentOperator(kind) {
   return kind >= import_ts_morph14.SyntaxKind.FirstAssignment && kind <= import_ts_morph14.SyntaxKind.LastAssignment;
 }
+function writesItsWholeValue(kind) {
+  return kind === import_ts_morph14.SyntaxKind.EqualsToken || kind === import_ts_morph14.SyntaxKind.QuestionQuestionEqualsToken || kind === import_ts_morph14.SyntaxKind.BarBarEqualsToken;
+}
 function writeAt(node) {
   if (import_ts_morph14.Node.isBinaryExpression(node)) {
     const operator = node.getOperatorToken().getKind();
@@ -2676,7 +2704,7 @@ function writeAt(node) {
     if (!isAssignmentOperator(operator) || !(import_ts_morph14.Node.isIdentifier(target) || import_ts_morph14.Node.isPropertyAccessExpression(target))) {
       return null;
     }
-    const value = operator === import_ts_morph14.SyntaxKind.EqualsToken ? node.getRight() : null;
+    const value = writesItsWholeValue(operator) ? node.getRight() : null;
     return { target, write: { value, node } };
   }
   if (import_ts_morph14.Node.isPrefixUnaryExpression(node) || import_ts_morph14.Node.isPostfixUnaryExpression(node)) {
@@ -3067,11 +3095,16 @@ function emitBindingValues(db, table, declaration) {
   }
   const { values, inOrder } = writesToBinding(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0) {
-    reassignedUnstated.add(declarationId);
+  if (inOrder && last !== void 0) {
+    fact(db, "endsHolding", declarationId, emitValue(db, table, last));
+    return;
+  }
+  const construction = sameConstructionAcrossWrites(values);
+  if (construction !== null) {
+    fact(db, "endsHolding", declarationId, emitValue(db, table, construction));
     return;
   }
-  fact(db, "endsHolding", declarationId, emitValue(db, table, last));
+  reassignedUnstated.add(declarationId);
 }
 var reassignedUnstated = /* @__PURE__ */ new Set();
 function reassignedNamesUnstated() {
@@ -3083,23 +3116,31 @@ function forgetReassignedNamesUnstated() {
 function emitFieldValues(db, table, declaration) {
   const { values, inOrder } = writesToField(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0 || !import_ts_morph15.Node.isExpression(last)) {
+  if (inOrder && last !== void 0 && import_ts_morph15.Node.isExpression(last)) {
+    fact(db, "binds", nodeId(declaration), emitValue(db, table, last));
     return;
   }
-  fact(db, "binds", nodeId(declaration), emitValue(db, table, last));
+  const construction = sameConstructionAcrossWrites(values);
+  if (construction !== null) {
+    fact(db, "binds", nodeId(declaration), emitValue(db, table, construction));
+  }
 }
 function emitParameterPropertyRead(db, table, referenceId, declaration) {
   const { values, inOrder } = writesToField(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0) {
+  if (inOrder && last !== void 0 && import_ts_morph15.Node.isExpression(last)) {
+    fact(db, "binds", referenceId, emitValue(db, table, last));
     return;
   }
-  if (!import_ts_morph15.Node.isExpression(last)) {
+  if (inOrder && last !== void 0) {
     table.byId.set(nodeId(last), last);
     fact(db, "binds", referenceId, nodeId(last));
     return;
   }
-  fact(db, "binds", referenceId, emitValue(db, table, last));
+  const construction = sameConstructionAcrossWrites(values);
+  if (construction !== null) {
+    fact(db, "binds", referenceId, emitValue(db, table, construction));
+  }
 }
 function emitBindingElementFacts(db, table, element) {
   const id = nodeId(element);
@@ -3563,7 +3604,8 @@ var JS_RULES = [
 ];
 var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
   rules: [...import_resolution2.RESOLUTION_RULES, ...JS_RULES, ...import_resolution2.RESOLUTION_QUESTIONS],
-  demandDriven: []
+  demandDriven: [],
+  demands: []
 } : (0, import_datalog2.deriveOnDemand)(
   [...import_resolution2.RESOLUTION_RULES, ...JS_RULES, ...import_resolution2.RESOLUTION_QUESTIONS],
   import_resolution2.ANSWER_RELATIONS
@@ -3590,7 +3632,9 @@ var QUERY_FACTS = RESOLUTION_PROGRAM.demandDriven.length === 0 ? [] : [
   "wantedAnchor",
   "wantedSubject"
 ];
-var MAX_MODULE_HOPS = 6;
+var MODULE_DEMANDS = RESOLUTION_PROGRAM.demands.filter(
+  (one) => (one.relation === "moduleExport" || one.relation === "moduleForwards") && one.bound[0] === true
+).map((one) => one.demand);
 var ResolutionStore = class {
   db = new import_datalog2.Database();
   table = createNodeTable();
@@ -3606,7 +3650,7 @@ var ResolutionStore = class {
    * extraction elsewhere cannot change an entry.
    */
   exportTables = /* @__PURE__ */ new Map();
-  /** Files the most recent wave walk entered, for the memo to keep. */
+  /** Files the most recent query read, for the memo to keep. */
   lastQueryWalked = [];
   declarations = /* @__PURE__ */ new Map();
   graph = new ModuleGraph();
@@ -3637,19 +3681,19 @@ var ResolutionStore = class {
    */
   resolveCallableSources(value, alsoFrom) {
     const target = factKeyOf(value);
-    return this.resolveByWaves(
+    return this.askAbout(
       target,
       "wanted",
       () => this.lookupSources(target),
       alsoFrom
-    ) ?? [];
+    );
   }
   /**
    * The witness proof behind `resolveCallable`'s answer. Resolves the
-   * value first, which walks files and extracts facts in the usual
-   * waves, then re-evaluates the rules over those base facts under the
-   * witness algebra and rebuilds the proof of the answer. Null when
-   * the value does not resolve at all.
+   * value first, which extracts the files the question demands, then
+   * re-evaluates the rules over those base facts under the witness
+   * algebra and rebuilds the proof of the answer. Null when the value
+   * does not resolve at all.
    */
   explainCallable(value, options = {}) {
     const resolved = this.resolveCallable(value, options.alsoFrom);
@@ -3686,11 +3730,7 @@ var ResolutionStore = class {
   }
   resolveObject(value) {
     const target = factKeyOf(value);
-    return this.resolveByWaves(
-      target,
-      "wanted",
-      () => this.lookupObject(target)
-    );
+    return this.askAbout(target, "wanted", () => this.lookupObject(target));
   }
   /**
    * For a value that is neither a function nor an object, such as a
@@ -3706,17 +3746,17 @@ var ResolutionStore = class {
       }
       return cached.written;
     }
-    const settled2 = this.resolveByWaves(
+    const written = this.askAbout(
       target,
       "wanted",
       () => this.lookupWritten(target)
     );
     this.writtenValues.set(key, {
-      written: settled2?.written ?? null,
+      written,
       walked: [...this.lastQueryWalked],
       extractedAt: this.fullyExtracted.size
     });
-    return settled2?.written ?? null;
+    return written;
   }
   /**
    * The construction behind a registration subject: the call or `new`
@@ -3736,18 +3776,29 @@ var ResolutionStore = class {
       }
       return cached.construction;
     }
-    const settled2 = this.resolveByWaves(
+    const settled2 = this.askAbout(
       target,
       "wantedSubject",
       () => this.lookupSubjectConstruction(target, importModule, importName)
     );
+    const walked = [...this.lastQueryWalked];
+    let resolved = settled2;
+    if (settled2.construction === null && settled2.candidate !== null && import_ts_morph16.Node.isCallExpression(settled2.candidate) && this.resolveCallable(settled2.candidate.getExpression()) !== null) {
+      const call = settled2.candidate;
+      resolved = this.askAbout(
+        call,
+        "wantedSubject",
+        () => this.lookupSubjectConstruction(call, importModule, importName)
+      );
+      walked.push(...this.lastQueryWalked);
+    }
     this.subjectConstructions.set(key, {
-      construction: settled2?.construction ?? null,
-      candidates: settled2?.candidates ?? 0,
-      walked: [...this.lastQueryWalked],
+      construction: resolved.construction,
+      candidates: resolved.candidates,
+      walked,
       extractedAt: this.fullyExtracted.size
     });
-    return settled2?.construction ?? null;
+    return resolved.construction;
   }
   /**
    * How many constructions this value was written as, which is what
@@ -3761,10 +3812,8 @@ var ResolutionStore = class {
     )?.candidates ?? 0;
   }
   /**
-   * The single-answer policy over the written-value walk, then the
-   * origin check on the one candidate. A candidate failing the check
-   * is settled refusal rather than a reason to widen: its own file's
-   * import facts are already in, and more files only add candidates.
+   * The single-answer policy over the written-value chain, then the
+   * origin check on the one candidate.
    */
   lookupSubjectConstruction(value, importModule, importName) {
     this.derive();
@@ -3780,6 +3829,7 @@ var ResolutionStore = class {
     if (candidates.size > 1) {
       return {
         construction: null,
+        candidate: null,
         candidates: [...candidates].filter(
           (one) => this.constructionComesFrom(valueId, one, importModule, importName)
         ).length
@@ -3787,7 +3837,7 @@ var ResolutionStore = class {
     }
     const single = [...candidates][0];
     if (single === void 0) {
-      return neverWritable(value) ? { construction: null, candidates: 0 } : null;
+      return { construction: null, candidate: null, candidates: 0 };
     }
     return {
       construction: this.constructionComesFrom(
@@ -3796,6 +3846,7 @@ var ResolutionStore = class {
         importModule,
         importName
       ) ? single : null,
+      candidate: single,
       candidates: 1
     };
   }
@@ -3855,11 +3906,11 @@ var ResolutionStore = class {
       return cached.names;
     }
     const target = factKeyOf(value);
-    const found = this.resolveByWaves(
+    const found = this.askAbout(
       target,
       "wantedOrigin",
       () => this.lookupImportedNames(target, modules)
-    ) ?? [];
+    );
     this.importedNames.set(declaration, {
       names: found,
       walked: [...this.lastQueryWalked]
@@ -3878,8 +3929,8 @@ var ResolutionStore = class {
     return this.importOriginsOfMany([value], modules).get(value) ?? [];
   }
   /**
-   * The batched form: one demand set, one derivation, one widening
-   * walk shared by every value. A discovery pass asks about every
+   * The batched form: one demand set, one derivation, one round of
+   * extraction shared by every value. A discovery pass asks about every
    * callee in a file, and per-value queries would re-pay demand
    * clearing and re-derivation once per call site.
    */
@@ -3907,49 +3958,12 @@ var ResolutionStore = class {
         this.wantValue("wantedCallOrigin", one.target);
         this.seedValue(one.target);
       }
-      const walked = /* @__PURE__ */ new Set();
-      this.lastQueryWalked = [];
-      let frontier = [];
+      this.extractDemanded(pending.map((one) => one.target.getSourceFile()));
       for (const one of pending) {
-        const file = one.target.getSourceFile();
-        if (!walked.has(file.getFilePath()) && !frontier.includes(file)) {
-          frontier.push(file);
-        }
-      }
-      const open = new Set(pending);
-      for (let hop = 0; hop <= MAX_MODULE_HOPS && open.size > 0; hop++) {
-        const next = [];
-        for (const sourceFile of frontier) {
-          if (walked.has(sourceFile.getFilePath())) {
-            continue;
-          }
-          walked.add(sourceFile.getFilePath());
-          this.lastQueryWalked.push(sourceFile.getFilePath());
-          recordFileDependency(sourceFile.getFilePath());
-          this.extractFile(sourceFile);
-          next.push(...this.graph.importedFilesOf(sourceFile));
-        }
-        for (const one of [...open]) {
-          const found = this.lookupImportOrigins(one.target, modules);
-          if (found !== null) {
-            results.set(one.value, found);
-            this.importOrigins.set(one.key, {
-              origins: found,
-              walked: [...this.lastQueryWalked],
-              extractedAt: this.fullyExtracted.size
-            });
-            open.delete(one);
-          }
-        }
-        if (next.length === 0) {
-          break;
-        }
-        frontier = next;
-      }
-      for (const one of open) {
-        results.set(one.value, []);
+        const origins = this.lookupImportOrigins(one.target, modules);
+        results.set(one.value, origins);
         this.importOrigins.set(one.key, {
-          origins: [],
+          origins,
           walked: [...this.lastQueryWalked],
           extractedAt: this.fullyExtracted.size
         });
@@ -4008,67 +4022,89 @@ var ResolutionStore = class {
     const refined = new Set(
       [...byPath.values()].filter((one) => one.path.length > 1).map((one) => (0, import_datalog2.tupleKey)(one.path.slice(0, -1)))
     );
-    const origins = [...byPath.values()].filter((one) => !refined.has((0, import_datalog2.tupleKey)(one.path))).sort((a, b) => a.path.join(".").localeCompare(b.path.join(".")));
-    if (origins.length > 0) {
-      return origins;
-    }
-    return all.some((one) => namesAPackage(one.module)) ? [] : null;
+    return [...byPath.values()].filter((one) => !refined.has((0, import_datalog2.tupleKey)(one.path))).sort((a, b) => a.path.join(".").localeCompare(b.path.join(".")));
   }
-  /**
-   * Null tells the walk to keep widening. A value that landed in a
-   * package returns empty instead, because a library's own body is not
-   * here to read and widening would never find anything.
-   */
   lookupImportedNames(value, modules) {
     this.derive();
-    const origins = this.answerPairsFor("wantedComesFrom", nodeId(value));
-    const reached = new Set(origins);
+    const reached = new Set(
+      this.answerPairsFor("wantedComesFrom", nodeId(value))
+    );
     for (const target of this.answersFor("wantedComesTo", nodeId(value))) {
       for (const entry of this.answerPairsFor("wantedCallsInto", target)) {
         reached.add(entry);
       }
     }
-    const names = namesFrom([...reached], modules);
-    if (names.length > 0) {
-      return names;
-    }
-    return origins.some((pair) => namesAPackage(pairHalves(pair).module)) ? [] : null;
+    return namesFrom([...reached], modules);
   }
-  resolveByWaves(value, question, ask, alsoFrom) {
+  askAbout(value, question, read2, alsoFrom) {
     try {
-      return this.walkForAnswer(value, question, ask, alsoFrom);
+      this.wantValue(question, value);
+      this.seedValue(value);
+      this.extractDemanded(
+        alsoFrom === void 0 ? [value.getSourceFile()] : [value.getSourceFile(), alsoFrom]
+      );
+      return read2();
     } finally {
       this.forgetQuery();
     }
   }
-  walkForAnswer(value, question, ask, alsoFrom) {
-    this.wantValue(question, value);
-    this.seedValue(value);
-    const walked = /* @__PURE__ */ new Set();
+  /**
+   * Extract the seed files, then every module the rules ask for, until
+   * they ask for nothing new. The files a question reads are then fixed
+   * by the question alone, so its answer does not depend on what an
+   * earlier question left in the store.
+   */
+  extractDemanded(seeds) {
+    const project = seeds[0]?.getProject();
+    if (project === void 0) {
+      return;
+    }
+    const read2 = /* @__PURE__ */ new Set();
+    const considered = /* @__PURE__ */ new Set();
     this.lastQueryWalked = [];
-    let frontier = alsoFrom === void 0 ? [value.getSourceFile()] : [value.getSourceFile(), alsoFrom];
-    for (let hop = 0; hop <= MAX_MODULE_HOPS; hop++) {
-      const next = [];
-      for (const sourceFile of frontier) {
-        if (walked.has(sourceFile.getFilePath())) {
+    let pending = [...seeds];
+    while (pending.length > 0) {
+      const readThisRound = [];
+      for (const sourceFile of pending) {
+        const filePath = sourceFile.getFilePath();
+        if (read2.has(filePath)) {
           continue;
         }
-        walked.add(sourceFile.getFilePath());
-        this.lastQueryWalked.push(sourceFile.getFilePath());
-        recordFileDependency(sourceFile.getFilePath());
+        read2.add(filePath);
+        readThisRound.push(filePath);
+        this.lastQueryWalked.push(filePath);
+        recordFileDependency(filePath);
         this.extractFile(sourceFile);
-        next.push(...this.graph.importedFilesOf(sourceFile));
-      }
-      const found = ask();
-      if (found !== null) {
-        return found;
       }
-      if (next.length === 0) {
-        return null;
+      this.derive();
+      pending = [];
+      for (const moduleKey of this.demandedModules(readThisRound)) {
+        if (considered.has(moduleKey)) {
+          continue;
+        }
+        considered.add(moduleKey);
+        const sourceFile = sourceFileFor(project, moduleKey);
+        if (sourceFile !== void 0 && !read2.has(sourceFile.getFilePath())) {
+          pending.push(sourceFile);
+        }
       }
-      frontier = next;
     }
-    return null;
+  }
+  /**
+   * Module keys the rules are waiting on. Demand facts are cleared
+   * between queries, so the demand relations contain this query's
+   * alone; the unrestricted program has none, and follows the imports
+   * of the files read this round instead.
+   */
+  demandedModules(readThisRound) {
+    if (RESOLUTION_PROGRAM.demands.length === 0) {
+      return readThisRound.flatMap(
+        (filePath) => this.db.lookup("importsModule", 0, filePath).map((tuple) => String(tuple[1]))
+      );
+    }
+    return MODULE_DEMANDS.flatMap(
+      (relation) => this.db.facts(relation).map((tuple) => String(tuple[0]))
+    );
   }
   /**
    * The question and the chain that settled it are dropped. The files
@@ -4087,6 +4123,27 @@ var ResolutionStore = class {
       this.stale = true;
     }
   }
+  wantExportsOf(filePath) {
+    if (this.db.add("wantedExportsOf", [filePath]) === "added") {
+      this.stale = true;
+    }
+  }
+  /**
+   * Discovery walks the table in order, and the rounds derive it in
+   * the order files arrived. Deriving it again from the demand alone,
+   * over the loaded closure, orders it by the file's own statements.
+   */
+  rederiveExportsOf(filePath) {
+    if (QUERY_FACTS.length === 0) {
+      return;
+    }
+    this.db.retract("wantedModuleExport", [
+      ...this.db.lookup("wantedModuleExport", 0, filePath)
+    ]);
+    this.forgetQuery();
+    this.wantExportsOf(filePath);
+    this.derive();
+  }
   /**
    * File extraction only reaches values hanging off exports, and a query
    * can be rooted anywhere, so the queried value gets its own facts.
@@ -4136,24 +4193,18 @@ var ResolutionStore = class {
       }
       candidates.add(node);
     }
-    if (candidates.size === 1) {
-      return { written: [...candidates][0] };
-    }
-    if (candidates.size > 1) {
-      return { written: null };
-    }
-    if (neverWritable(value)) {
-      return { written: null };
+    if (candidates.size !== 1) {
+      return null;
     }
-    return null;
+    return [...candidates][0];
   }
   /**
    * Read these files' facts now, before anything asks a question.
    *
-   * A query widens along the imports of the file it starts in, which
-   * is where a value's definition is. What a caller passed is the other
+   * A query follows the imports of the file it starts in, which is
+   * where a value's definition is. What a caller passed is the other
    * direction, so a question about a parameter is answered only by
-   * files the walk never reaches on its own.
+   * files the query never reaches on its own.
    */
   extractFiles(sourceFiles) {
     for (const sourceFile of sourceFiles) {
@@ -4169,15 +4220,14 @@ var ResolutionStore = class {
     return this.graph.filesReachingAnyPackage(fileSets);
   }
   /**
-   * The calls behind a receiver that `matches` accepts, walked out in
-   * waves the way every question is. The wave ends as soon as one file
-   * yields a match, and the caller applies the single-answer policy to
-   * the set; the resolution README's anchor section says why the rules
-   * cannot rank a nearer call above a farther one.
+   * The calls behind a receiver that `matches` accepts. The caller
+   * applies the single-answer policy to the set; the resolution
+   * README's anchor section says why the rules cannot rank a nearer
+   * call above a farther one.
    */
   anchorCallsOf(value, matches) {
     const target = factKeyOf(value);
-    return this.resolveByWaves(target, "wantedAnchor", () => {
+    return this.askAbout(target, "wantedAnchor", () => {
       this.derive();
       const found = [];
       for (const id of this.answersFor("wantedAnchorCall", nodeId(target))) {
@@ -4186,12 +4236,12 @@ var ResolutionStore = class {
           found.push(node);
         }
       }
-      return found.length === 0 ? null : found;
-    }) ?? [];
+      return found;
+    });
   }
   /**
    * Every name a module exports and the values behind each, with
-   * re-export chains flattened by the rules. The frontier follows
+   * re-export chains flattened by the rules. The demand follows
    * re-export targets only, so a barrel of barrels extracts its own
    * chain and nothing beside it, to any depth.
    */
@@ -4211,33 +4261,10 @@ var ResolutionStore = class {
     }
   }
   collectExports(sourceFile) {
-    const project = sourceFile.getProject();
-    const walked = /* @__PURE__ */ new Set();
-    let frontier = [sourceFile];
-    while (frontier.length > 0) {
-      const next = [];
-      for (const file of frontier) {
-        const filePath2 = file.getFilePath();
-        if (walked.has(filePath2)) {
-          continue;
-        }
-        walked.add(filePath2);
-        recordFileDependency(filePath2);
-        this.extractFile(file);
-        for (const target of this.reExportTargetsOf(filePath2)) {
-          const targetFile = sourceFileFor(project, target);
-          if (targetFile !== void 0) {
-            next.push(targetFile);
-          }
-        }
-      }
-      frontier = next;
-    }
     const filePath = sourceFile.getFilePath();
-    if (this.db.add("wantedExportsOf", [filePath]) === "added") {
-      this.stale = true;
-    }
-    this.derive();
+    this.wantExportsOf(filePath);
+    this.extractDemanded([sourceFile]);
+    this.rederiveExportsOf(filePath);
     const exports2 = /* @__PURE__ */ new Map();
     for (const tuple of this.db.lookup("wantedModuleExport", 0, filePath)) {
       const node = this.table.byId.get(String(tuple[2]));
@@ -4254,22 +4281,9 @@ var ResolutionStore = class {
     }
     return exports2;
   }
-  /** Module keys this file re-exports from, read off its own facts. */
-  reExportTargetsOf(filePath) {
-    const targets = /* @__PURE__ */ new Set();
-    for (const tuple of this.db.lookup("reExports", 0, filePath)) {
-      targets.add(String(tuple[2]));
-    }
-    for (const tuple of this.db.lookup("reExportsAll", 0, filePath)) {
-      targets.add(String(tuple[1]));
-    }
-    return [...targets];
-  }
   /**
-   * Null keeps the wave walk widening; any candidate at all ends it,
-   * since more files can only add candidates, never take one away. The
-   * single-answer policy stays with the callers: picking one of two
-   * would make the result depend on the order the facts came in.
+   * The single-answer policy stays with the callers: a value with two
+   * sources is something to say at the site, not something to pick from.
    */
   lookupSources(value) {
     this.derive();
@@ -4283,7 +4297,7 @@ var ResolutionStore = class {
         candidates.add(resolved);
       }
     }
-    return candidates.size === 0 ? null : [...candidates];
+    return [...candidates];
   }
   derive() {
     if (!this.stale) {
@@ -4342,18 +4356,6 @@ function pairHalves(pair) {
   const [module2 = "", name = ""] = (0, import_datalog2.tupleKeyParts)(pair);
   return { module: module2, name };
 }
-function namesAPackage(moduleKey) {
-  return !moduleKey.startsWith("/") || moduleKey.includes("/node_modules/");
-}
-function neverWritable(value) {
-  if (!import_ts_morph16.Node.isIdentifier(value)) {
-    return false;
-  }
-  const declarations = value.getSymbol()?.getDeclarations() ?? [];
-  return declarations.some(
-    (declaration) => declaration.getSourceFile().getFilePath().includes("/node_modules/")
-  );
-}
 function namesPackage2(moduleKey, packages) {
   return namesAnyPackage(
     [moduleKey, ...packagesDeclaring(moduleKey)],
@@ -4374,35 +4376,7 @@ 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_behavioral_ir = require("@suss/behavioral-ir");
-var emptyTally = () => ({
-  candidateFiles: 0,
-  unitsDiscovered: 0,
-  unitsInGatedFiles: 0,
-  effectsRecognized: 0,
-  unitsClaimed: 0,
-  selfCollisions: 0,
-  summariesProduced: 0,
-  failures: [],
-  helpersMatched: /* @__PURE__ */ new Set()
-});
-function recordPackFailure(tally, failure) {
-  const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
-  tally?.failures.push({
-    hook: failure.hook,
-    file: failure.file,
-    message
-  });
-  return `[suss] pack "${failure.pack}" threw from ${failure.hook} while reading ${failure.file}: ${message}
-`;
-}
-function createPackTallies(packs) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const pack of packs) {
-    tallies.set(pack.name, emptyTally());
-  }
-  return tallies;
-}
+var import_extractor3 = require("@suss/extractor");
 function commonDirectoryOf(files) {
   const absolute = files.filter((f) => import_node_path2.default.isAbsolute(f));
   const first = absolute[0];
@@ -4479,30 +4453,6 @@ function unresolvedGatesFor(gates, args) {
   }
   return unresolved;
 }
-var emptyCounts = () => ({
-  bound: 0,
-  providers: 0,
-  withBehavior: 0
-});
-function summaryCountsByPack(summaries) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const summary of summaries) {
-    const recognition = summary.identity.boundaryBinding?.recognition;
-    if (recognition === void 0 || recognition === null) {
-      continue;
-    }
-    const entry = counts.get(recognition) ?? emptyCounts();
-    entry.bound += 1;
-    if (import_behavioral_ir.BOUNDARY_ROLE[summary.kind] === "provider") {
-      entry.providers += 1;
-    }
-    if (summary.transitions.length > 0) {
-      entry.withBehavior += 1;
-    }
-    counts.set(recognition, entry);
-  }
-  return counts;
-}
 function helpersWithNoCall(patterns, matched, projectRoot) {
   const missing = [];
   for (const pattern of patterns) {
@@ -4523,11 +4473,15 @@ function shortModule(module2, projectRoot) {
   return import_node_path2.default.relative(projectRoot, module2);
 }
 function buildExtractionReport(args) {
-  const bySummary = summaryCountsByPack(args.summaries);
+  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) ?? emptyTally();
-    const counted = bySummary.get(pack.name) ?? emptyCounts();
+    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,
@@ -4756,13 +4710,26 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (import_ts_morph18.Node.isCallExpression(written) || import_ts_morph18.Node.isNewExpression(written)) {
+  if (import_ts_morph18.Node.isNewExpression(written)) {
     return written;
   }
+  if (import_ts_morph18.Node.isCallExpression(written)) {
+    return writtenThroughCall(written, resolution);
+  }
   if (resolution === void 0 || !couldNameAValue(written)) {
     return null;
   }
-  return resolution.resolveWrittenValue(written);
+  const resolved = resolution.resolveWrittenValue(written);
+  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) {
+    const resolved = resolution.resolveWrittenValue(call);
+    if (resolved !== null) {
+      return resolved;
+    }
+  }
+  return call;
 }
 function stringValueOf(value, resolution) {
   const written = factKeyOf(value);
@@ -4824,7 +4791,7 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
       }
     } else if (import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText()) || resolvesToKnownInstance(subject, match, resolution))) {
+      if (import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -6428,14 +6395,14 @@ function unitForJsxRoute(node, match, routeNames, kind, resolution) {
   }
   return routeUnit(node, kind, match.method, resolved.path, target, resolution);
 }
-function routeUnit(at, kind, method, path15, target, resolution) {
-  const routeInfo = { method, path: path15 };
+function routeUnit(at, kind, method, path14, target, resolution) {
+  const routeInfo = { method, path: path14 };
   if (target.kind === "unreadable") {
     return {
       func: null,
       announcedAt: at,
       kind,
-      name: path15,
+      name: path14,
       nameKind: "label",
       routeInfo
     };
@@ -6634,7 +6601,6 @@ function labelOfExpression(node) {
 }
 
 // src/discovery/packageExports.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
 var import_ts_morph31 = require("ts-morph");
 
 // src/packageExports.ts
@@ -6663,7 +6629,8 @@ function resolvePackageExports(packageJsonPath, opts = {}) {
       packageName,
       subPath,
       exportPathPrefix: subPathToPrefix(subPath),
-      sourceFile: src
+      sourceFile: src,
+      publishedFile: import_node_path5.default.resolve(pkgDir, distPath)
     });
   };
   const exportsField = pkg.exports;
@@ -6683,6 +6650,53 @@ function resolvePackageExports(packageJsonPath, opts = {}) {
   }
   return { packageName, entries, warnings };
 }
+var packageExportsCache = /* @__PURE__ */ new Map();
+var PATH_STAMP_SEPARATOR = "";
+function packageJsonStamp(packageJsonPath) {
+  try {
+    const stat = import_node_fs2.default.statSync(packageJsonPath);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return "unreadable";
+  }
+}
+function resolvePackageExportsCached(packageJsonPath) {
+  const stamp2 = packageJsonStamp(packageJsonPath);
+  const key = `${packageJsonPath}${PATH_STAMP_SEPARATOR}${stamp2}`;
+  const cached = packageExportsCache.get(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const fresh = resolvePackageExports(packageJsonPath);
+  packageExportsCache.set(key, fresh);
+  return fresh;
+}
+function namedPackageDirAbove(start) {
+  let at = import_node_path5.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);
+    if (parent === at) {
+      break;
+    }
+    at = parent;
+  }
+  return null;
+}
+function packageNameAt(dir) {
+  try {
+    const manifest = JSON.parse(
+      import_node_fs2.default.readFileSync(import_node_path5.default.join(dir, "package.json"), "utf8")
+    );
+    if (typeof manifest.name === "string" && manifest.name.length > 0) {
+      return manifest.name;
+    }
+  } catch {
+  }
+  return null;
+}
 function pickConditional(value, warnings, key) {
   if (value === void 0 || value === null) {
     if (value === null) {
@@ -6732,8 +6746,55 @@ function resolveSourceFor(pkgDir, distPath, srcRoot) {
   return null;
 }
 
+// src/resolve/sourceDeclaration.ts
+var import_node_path6 = __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()));
+  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")
+  );
+  const found = [];
+  for (const entry of entries) {
+    const published = sourceFileFor(project, entry.publishedFile);
+    const source = sourceFileFor(project, entry.sourceFile);
+    if (published === void 0 || source === void 0) {
+      continue;
+    }
+    for (const [name, nodes] of resolution.exportsOf(published)) {
+      if (!nodes.some((node) => sameDeclaration(node, decl))) {
+        continue;
+      }
+      for (const behind of resolution.exportsOf(source).get(name) ?? []) {
+        for (const candidate of sourceDeclarationsBehind(
+          behind,
+          resolution,
+          visited
+        )) {
+          if (!found.includes(candidate)) {
+            found.push(candidate);
+          }
+        }
+      }
+    }
+  }
+  return found.length > 0 ? found : [decl];
+}
+function sameDeclaration(a, b) {
+  return a === b || a.getSourceFile().getFilePath() === b.getSourceFile().getFilePath() && a.getStart() === b.getStart() && a.getEnd() === b.getEnd();
+}
+
 // src/discovery/factorySurface.ts
 var import_ts_morph30 = require("ts-morph");
+var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl) {
   if (import_ts_morph30.Node.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
@@ -6773,16 +6834,20 @@ function surfaceClassMethods(cls) {
 function surfaceFactoryReturnMethods(fn) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
+  collectFromFunctionReturns(fn, out, seen, 0);
+  return out;
+}
+function collectFromFunctionReturns(fn, out, seen, depth) {
   if (import_ts_morph30.Node.isArrowFunction(fn)) {
     const body2 = fn.getBody();
     if (import_ts_morph30.Node.isExpression(body2)) {
-      collectFromObjectLiteral(body2, out, seen);
-      return out;
+      collectFromReturnValue(body2, out, seen, depth);
+      return;
     }
   }
   const body = fn.getBody?.();
   if (body === void 0) {
-    return out;
+    return;
   }
   const returns = [];
   body.forEachDescendant((node, traversal) => {
@@ -6799,9 +6864,53 @@ function surfaceFactoryReturnMethods(fn) {
     if (expr === void 0) {
       continue;
     }
+    collectFromReturnValue(expr, out, seen, depth);
+  }
+}
+function collectFromReturnValue(node, out, seen, depth) {
+  const expr = peelParens(node);
+  if (import_ts_morph30.Node.isObjectLiteralExpression(expr)) {
     collectFromObjectLiteral(expr, out, seen);
+    return;
   }
-  return out;
+  if (depth >= MAX_BUILDER_HOPS || !import_ts_morph30.Node.isCallExpression(expr)) {
+    return;
+  }
+  const callee = expr.getExpression();
+  if (!import_ts_morph30.Node.isIdentifier(callee)) {
+    return;
+  }
+  const helper = sameFileFunctionBehind(callee);
+  if (helper !== null) {
+    collectFromFunctionReturns(helper, out, seen, depth + 1);
+  }
+}
+function sameFileFunctionBehind(id) {
+  const symbol = id.getSymbol();
+  if (symbol === void 0) {
+    return null;
+  }
+  return functionAmong(
+    symbol.getDeclarations(),
+    id.getSourceFile().getFilePath()
+  );
+}
+function functionAmong(declarations, filePath) {
+  for (const decl of declarations) {
+    if (decl.getSourceFile().getFilePath() !== filePath) {
+      continue;
+    }
+    if (import_ts_morph30.Node.isFunctionDeclaration(decl)) {
+      return decl;
+    }
+    if (import_ts_morph30.Node.isVariableDeclaration(decl)) {
+      const init = decl.getInitializer();
+      if (init !== void 0 && (import_ts_morph30.Node.isArrowFunction(init) || import_ts_morph30.Node.isFunctionExpression(init))) {
+        return init;
+      }
+    }
+  }
+  return null;
 }
 function collectFromObjectLiteral(node, out, seen) {
   const e = peelParens(node);
@@ -6836,31 +6945,31 @@ function collectFromObjectLiteral(node, out, seen) {
         out.push({ func: v3, name });
       }
     }
+    if (import_ts_morph30.Node.isShorthandPropertyAssignment(prop)) {
+      collectShorthandFunction(prop, out, seen);
+    }
   }
 }
-
-// src/discovery/packageExports.ts
-var packageExportsCache = /* @__PURE__ */ new Map();
-var PATH_STAMP_SEPARATOR = "";
-function packageJsonStamp(packageJsonPath) {
-  try {
-    const stat = import_node_fs3.default.statSync(packageJsonPath);
-    return `${stat.mtimeMs}:${stat.size}`;
-  } catch {
-    return "unreadable";
+function collectShorthandFunction(prop, out, seen) {
+  const name = prop.getName();
+  if (seen.has(name)) {
+    return;
   }
-}
-function resolvePackageExportsCached(packageJsonPath) {
-  const stamp = packageJsonStamp(packageJsonPath);
-  const key = `${packageJsonPath}${PATH_STAMP_SEPARATOR}${stamp}`;
-  const cached = packageExportsCache.get(key);
-  if (cached !== void 0) {
-    return cached;
+  const symbol = prop.getValueSymbol();
+  if (symbol === void 0) {
+    return;
+  }
+  const fn = functionAmong(
+    symbol.getDeclarations(),
+    prop.getSourceFile().getFilePath()
+  );
+  if (fn !== null) {
+    seen.add(name);
+    out.push({ func: fn, name });
   }
-  const fresh = resolvePackageExports(packageJsonPath);
-  packageExportsCache.set(key, fresh);
-  return fresh;
 }
+
+// src/discovery/packageExports.ts
 function discoverPackageExports(sourceFile, match, kind, resolution) {
   if (match.packageJsonPath === void 0) {
     return [];
@@ -6895,7 +7004,10 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
       if (seenNames.has(key)) {
         continue;
       }
-      for (const decl of decls) {
+      const candidates = decls.flatMap(
+        (decl) => sourceDeclarationsBehind(decl, resolution)
+      );
+      for (const decl of candidates) {
         if (import_ts_morph31.Node.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
           if (init !== void 0 && (import_ts_morph31.Node.isArrowFunction(init) || import_ts_morph31.Node.isFunctionExpression(init))) {
@@ -7048,7 +7160,7 @@ function attributedCalls(sourceFile, packages, resolution) {
       return null;
     }
     if (!methodComesFromSource(callee)) {
-      return subject;
+      return null;
     }
     return {
       packageName: subject.packageName,
@@ -7162,12 +7274,12 @@ function originEndOf(flattened) {
   const slash = flattened.indexOf("/", opener[0].length);
   return slash === -1 ? flattened.length : slash;
 }
-function appendPathText(path15, text) {
+function appendPathText(path14, text) {
   const idx = text.search(/[?#]/);
   if (idx === -1) {
-    return { path: path15 + text, stop: false };
+    return { path: path14 + text, stop: false };
   }
-  return { path: path15 + text.slice(0, idx), stop: true };
+  return { path: path14 + text.slice(0, idx), stop: true };
 }
 function parseAbsoluteUrl(text) {
   try {
@@ -7191,8 +7303,8 @@ function pathnameOfAbsoluteLiteral(text) {
   return stripQueryAndFragment(stripOriginManually(text));
 }
 function pathFromLiteralUrl(text) {
-  const path15 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
-  return path15 === "" ? void 0 : path15;
+  const path14 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
+  return path14 === "" ? void 0 : path14;
 }
 function pathFromTemplateUrl(arg, resolution) {
   const headText = arg.getHead().getLiteralText();
@@ -7200,7 +7312,7 @@ function pathFromTemplateUrl(arg, resolution) {
   const tails = spans.map((span) => span.getLiteral().getLiteralText());
   const originEnd = originEndOf([headText, ...tails].join(SUBSTITUTION));
   const head = appendPathText("", headText.slice(originEnd));
-  let path15 = head.path;
+  let path14 = head.path;
   let stop = head.stop;
   let at = headText.length;
   for (let i = 0; i < spans.length && !stop; i++) {
@@ -7210,18 +7322,18 @@ function pathFromTemplateUrl(arg, resolution) {
       continue;
     }
     if (at >= originEnd) {
-      path15 += holeText(span.getExpression(), resolution);
+      path14 += holeText(span.getExpression(), resolution);
     }
     at += SUBSTITUTION.length;
     const appended = appendPathText(
-      path15,
+      path14,
       tailText.slice(Math.max(0, originEnd - at))
     );
-    path15 = appended.path;
+    path14 = appended.path;
     stop = appended.stop;
     at += tailText.length;
   }
-  return path15 === "" ? void 0 : path15;
+  return path14 === "" ? void 0 : path14;
 }
 function pathFromUrlNode(node, resolution) {
   if (import_ts_morph33.Node.isStringLiteral(node)) {
@@ -7291,12 +7403,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     match.importName,
     resolution
   );
-  if (registrationSubjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution)) {
-    return results;
-  }
   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_morph34.Node.isCallExpression(node)) {
       return;
@@ -7490,8 +7602,54 @@ function receiverOf(subject, subjects, match, resolution) {
   );
   return candidates > 1 ? { kind: "several", candidates } : NOT_A_ROUTABLE;
 }
-function storeCanFindSubjects(sourceFile, match, resolution) {
-  return resolution !== void 0 && importDeclarationsOf(sourceFile, [match.importModule]).length > 0;
+function storeCanFindSubjects(sourceFile, match, resolution, methods = []) {
+  if (resolution === void 0) {
+    return false;
+  }
+  if (importDeclarationsOf(sourceFile, [match.importModule]).length > 0) {
+    return true;
+  }
+  return methods.length > 0 && callsOnCallResult(sourceFile, methods);
+}
+function callsOnCallResult(sourceFile, methods) {
+  let called = methodsCalledOnCallResults.get(sourceFile);
+  if (called === void 0) {
+    called = collectMethodsCalledOnCallResults(sourceFile);
+    methodsCalledOnCallResults.set(sourceFile, called);
+  }
+  return methods.some((method) => called.has(method));
+}
+var methodsCalledOnCallResults = /* @__PURE__ */ new WeakMap();
+function collectMethodsCalledOnCallResults(sourceFile) {
+  const setToCalls = /* @__PURE__ */ new Set();
+  const calledOn = /* @__PURE__ */ new Map();
+  sourceFile.forEachDescendant((node) => {
+    if (import_ts_morph34.Node.isVariableDeclaration(node)) {
+      const init = node.getInitializer();
+      if (init !== void 0 && import_ts_morph34.Node.isCallExpression(init)) {
+        setToCalls.add(node.getName());
+      }
+      return;
+    }
+    if (!import_ts_morph34.Node.isCallExpression(node)) {
+      return;
+    }
+    const callee = node.getExpression();
+    if (!import_ts_morph34.Node.isPropertyAccessExpression(callee) || !import_ts_morph34.Node.isIdentifier(callee.getExpression())) {
+      return;
+    }
+    const receiver = callee.getExpression().getText();
+    const methods = calledOn.get(receiver) ?? /* @__PURE__ */ new Set();
+    methods.add(callee.getName());
+    calledOn.set(receiver, methods);
+  });
+  const called = /* @__PURE__ */ new Set();
+  for (const name of setToCalls) {
+    for (const method of calledOn.get(name) ?? []) {
+      called.add(method);
+    }
+  }
+  return called;
 }
 function registrationSubjectsOf(sourceFile, importModule, importName, resolution) {
   const importedLocalName = resolveImportedLocalName(
@@ -7556,9 +7714,33 @@ function registrationSubjectIdsOf(sourceFile, matches, resolution) {
     ).values()) {
       ids.add(nodeId(node));
     }
+    for (const node of unboundConstructionsOf(
+      sourceFile,
+      match.importModule,
+      match.importName
+    )) {
+      ids.add(nodeId(node));
+    }
   }
   return ids;
 }
+function unboundConstructionsOf(sourceFile, importModule, importName) {
+  const importedLocalName = resolveImportedLocalName(
+    sourceFile,
+    importModule,
+    importName
+  );
+  if (importedLocalName === null) {
+    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())) {
+      constructions.push(node);
+    }
+  });
+  return constructions;
+}
 function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolution) {
   const subjects = registrationSubjectsOf(
     sourceFile,
@@ -7566,7 +7748,7 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
     match.importName,
     resolution
   );
-  if (subjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution)) {
+  if (subjects.size === 0 && !storeCanFindSubjects(sourceFile, match, resolution, [mount.method])) {
     return [];
   }
   const edges = [];
@@ -7647,11 +7829,11 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
       return null;
     }
     const method2 = stringProperty(routeObject, binding.method.property);
-    const path16 = stringProperty(routeObject, binding.path.property);
-    if (method2 === null || path16 === null) {
+    const path15 = stringProperty(routeObject, binding.path.property);
+    if (method2 === null || path15 === null) {
       return null;
     }
-    return { method: method2.toUpperCase(), path: path16 };
+    return { method: method2.toUpperCase(), path: path15 };
   }
   if (binding.method.type !== "fromRegistration" || binding.path.type !== "fromArgument") {
     return null;
@@ -7668,8 +7850,8 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
     method = arg.getLiteralValue().toUpperCase();
   }
   const pathArg = call.getArguments()[binding.path.position];
-  const path15 = pathArg === void 0 ? void 0 : pathFromArgument(pathArg, resolution);
-  return path15 === void 0 ? null : { method, path: path15 };
+  const path14 = pathArg === void 0 ? void 0 : pathFromArgument(pathArg, resolution);
+  return path14 === void 0 ? null : { method, path: path14 };
 }
 
 // src/discovery/registrationLoop.ts
@@ -7801,7 +7983,7 @@ function bodyCallsOnRoutable(loop, guard, resolution) {
 }
 function readRouteSpec(element, shape, resolution) {
   let method = null;
-  let path15 = null;
+  let path14 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
     if (import_ts_morph35.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
@@ -7819,16 +8001,16 @@ function readRouteSpec(element, shape, resolution) {
     if (name === shape.methodKey) {
       method = readStringLiteralValue(init);
     } else if (name === shape.pathKey) {
-      path15 = readStringLiteralValue(init);
+      path14 = readStringLiteralValue(init);
     } else if (name === shape.handlerKey) {
       const func = functionValueOf(init, resolution);
       handler = func === null ? null : { func, name: handlerName(init) };
     }
   }
-  if (method === null || path15 === null || handler === null) {
+  if (method === null || path14 === null || handler === null) {
     return null;
   }
-  return { method, path: path15, handler: handler.func, handlerName: handler.name };
+  return { method, path: path14, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
   if (import_ts_morph35.Node.isStringLiteral(node) || import_ts_morph35.Node.isNoSubstitutionTemplateLiteral(node)) {
@@ -7841,12 +8023,13 @@ function handlerName(value) {
 }
 
 // src/discovery/registrationTemplate.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __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_ir3 = require("@suss/behavioral-ir");
 function isInExternalCode(sourceFile) {
   if (sourceFile.isDeclarationFile()) {
     return true;
@@ -7900,6 +8083,19 @@ function declarationsBehind(symbol) {
 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";
@@ -7920,36 +8116,6 @@ function classifyStop(declarations, scanning) {
   }
   return "unsettledValue";
 }
-var RECORDED = {
-  noBody: true,
-  unsettledValue: true,
-  multipleSources: true,
-  outsideRun: false,
-  noDeclaration: false,
-  callerSupplied: false,
-  multipleReceivers: true
-};
-function worthRecording(reason) {
-  return RECORDED[reason];
-}
-var STOP_SENTENCE = {
-  noBody: ({ callee }) => `The call to ${callee} lands on a declaration with no body, so whatever runs there is missing from this summary`,
-  unsettledValue: ({ callee }) => `The call to ${callee} goes through a value this run could not settle, so whatever runs there is missing from this summary`,
-  multipleSources: ({ callee }) => `The call to ${callee} reaches a value with more than one possible source, so whatever runs there is missing from this summary`,
-  outsideRun: ({ callee }) => `The call to ${callee} lands in a package whose source is not in this run, so whatever runs there is missing from this summary`,
-  noDeclaration: ({ callee }) => `The call to ${callee} has no declaration this run could find, so whatever runs there is missing from this summary`,
-  callerSupplied: ({ callee }) => `The call to ${callee} runs the function this unit's caller passed in, so what happens there is decided at the call site`,
-  multipleReceivers: ({ callee, candidates }) => `The call to ${callee} is made on a receiver this run reads as ${candidates ?? "several"} different values, so nothing says which one it registers on and the registration is left out`
-};
-function unfollowedCallGap(stop) {
-  return {
-    type: "unfollowedCall",
-    conditions: [],
-    consequence: "unknown",
-    description: STOP_SENTENCE[stop.reason](stop),
-    callee: stop.callee
-  };
-}
 
 // src/discovery/registrationTemplate.ts
 function discoverRegistrationTemplates(sourceFile, match, kind, resolution, mountPrefixes) {
@@ -7959,8 +8125,8 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution, moun
     const subject = subjectOfCall(sourceFile, args, match, resolution);
     const prefix = subject === void 0 ? "" : mountPrefixes?.effectivePrefixFor(subject) ?? "";
     for (const reg of match.registrations) {
-      const path15 = substitutePath(reg.pathTemplate, args);
-      if (path15 === null) {
+      const path14 = substitutePath(reg.pathTemplate, args);
+      if (path14 === null) {
         continue;
       }
       const handler = resolveHandler(reg.handlerArg, args, resolution);
@@ -7974,7 +8140,7 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution, moun
         ...subject === void 0 ? {} : { registrationSubjectId: nodeId(subject) },
         routeInfo: {
           method: reg.method.toUpperCase(),
-          path: prefix === "" ? path15 : (0, import_resolution4.joinMountedPath)(prefix, path15)
+          path: prefix === "" ? path14 : (0, import_resolution4.joinMountedPath)(prefix, path14)
         }
       });
     }
@@ -8007,7 +8173,7 @@ function subjectOfCall(sourceFile, args, match, resolution) {
 }
 function helperCallsOf(sourceFile, match, resolution) {
   const module2 = match.importModule;
-  if (module2 !== void 0 && !import_node_path6.default.isAbsolute(module2)) {
+  if (module2 !== void 0 && !import_node_path7.default.isAbsolute(module2)) {
     const store = resolution ?? new ResolutionStore();
     return callsResolvingTo(sourceFile, store, {
       module: module2,
@@ -8453,24 +8619,24 @@ function declName(decl) {
 
 // src/parameterReads.ts
 function pathAbove(reference) {
-  const path15 = [];
+  const path14 = [];
   let current2 = reference;
   for (; ; ) {
     const parent = current2.getParent();
     if (parent !== void 0 && import_ts_morph40.Node.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
-      path15.push(parent.getName());
+      path14.push(parent.getName());
       current2 = parent;
       continue;
     }
     if (parent !== void 0 && import_ts_morph40.Node.isElementAccessExpression(parent) && parent.getExpression() === current2) {
       const argument = parent.getArgumentExpression();
       if (argument !== void 0 && import_ts_morph40.Node.isStringLiteral(argument)) {
-        path15.push(argument.getLiteralValue());
+        path14.push(argument.getLiteralValue());
         current2 = parent;
         continue;
       }
     }
-    return path15;
+    return path14;
   }
 }
 function declaresParameterOf(node, func) {
@@ -8518,7 +8684,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
 
 // src/resolve/readName.ts
 var import_ts_morph41 = require("ts-morph");
-var import_behavioral_ir3 = require("@suss/behavioral-ir");
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -8533,7 +8699,7 @@ function readName(expr, options = {}) {
     return name;
   }
   const reference = referenceIn(expr);
-  return reference === null ? null : (0, import_behavioral_ir3.referenceName)(reference);
+  return reference === null ? null : (0, import_behavioral_ir4.referenceName)(reference);
 }
 function referenceIn(expr) {
   const fromParameter = parameterPath(expr);
@@ -8782,7 +8948,7 @@ function boundOnce(expr, ctx) {
 }
 function readOrHole(expr, ctx) {
   const name = read(expr, ctx);
-  return name ?? (0, import_behavioral_ir3.patternHole)(holeName(expr, ctx));
+  return name ?? (0, import_behavioral_ir4.patternHole)(holeName(expr, ctx));
 }
 function holeName(expr, ctx) {
   const bound = boundOnce(expr, ctx);
@@ -9169,142 +9335,40 @@ function importSpecifierMatches(decl, expectedModule) {
   return import_ts_morph43.Node.isImportDeclaration(importDecl) && importDecl.getModuleSpecifierValue() === expectedModule;
 }
 function extractInvocationEffects(func, barriers = NO_BARRIERS) {
-  const results = [];
+  const calls = [];
   func.forEachDescendant((node, traversal) => {
-    if (isDescentStop(node, func, barriers)) {
+    if (isDescentStop(node, func, barriers) || import_ts_morph43.Node.isDecorator(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph43.Node.isExpressionStatement(node)) {
-      const { call, async } = unwrapCall(node.getExpression());
-      if (call !== null) {
-        const preconditions = collectPreconditions(node, func);
-        results.push({
-          effect: {
-            type: "invocation",
-            callee: call.getExpression().getText(),
-            args: extractArgs(call),
-            async,
-            ...preconditions.length > 0 ? { preconditions } : {}
-          },
-          line: startLineOf(node),
-          neverTerminal: false,
-          alwaysRuns: runsOnEveryPath(node, func)
-        });
-      }
-      return;
-    }
-    if (import_ts_morph43.Node.isSpreadElement(node)) {
-      const parent = node.getParent();
-      if (parent !== void 0 && (import_ts_morph43.Node.isArrayLiteralExpression(parent) || import_ts_morph43.Node.isObjectLiteralExpression(parent))) {
-        const { call, async } = unwrapCall(node.getExpression());
-        if (call !== null) {
-          const preconditions = collectPreconditions(node, func);
-          results.push({
-            effect: {
-              type: "invocation",
-              callee: call.getExpression().getText(),
-              args: extractArgs(call),
-              async,
-              ...preconditions.length > 0 ? { preconditions } : {}
-            },
-            line: enclosingStatementLine(node),
-            neverTerminal: true,
-            alwaysRuns: runsOnEveryPath(node, func)
-          });
-        }
-      }
-      return;
-    }
-    if (import_ts_morph43.Node.isVariableDeclaration(node)) {
-      const initializer = node.getInitializer();
-      if (initializer !== void 0) {
-        const { call, async } = unwrapCall(initializer);
-        if (call !== null) {
-          const preconditions = collectPreconditions(node, func);
-          results.push({
-            effect: {
-              type: "invocation",
-              callee: call.getExpression().getText(),
-              args: extractArgs(call),
-              async,
-              ...preconditions.length > 0 ? { preconditions } : {}
-            },
-            line: enclosingStatementLine(node),
-            neverTerminal: true,
-            alwaysRuns: runsOnEveryPath(node, func)
-          });
-        }
-      }
-      return;
-    }
-    if (import_ts_morph43.Node.isReturnStatement(node)) {
-      const returned = node.getExpression();
-      const { call, async } = returned === void 0 ? { call: null, async: false } : unwrapCall(returned);
-      if (call !== null) {
-        const preconditions = collectPreconditions(node, func);
-        results.push({
-          effect: {
-            type: "invocation",
-            callee: call.getExpression().getText(),
-            args: extractArgs(call),
-            async,
-            ...preconditions.length > 0 ? { preconditions } : {}
-          },
-          line: startLineOf(node),
-          neverTerminal: false,
-          alwaysRuns: runsOnEveryPath(node, func),
-          node: call
-        });
-      }
-      return;
-    }
-    if (import_ts_morph43.Node.isArrowFunction(node)) {
-      const body = node.getBody();
-      const { call, async } = import_ts_morph43.Node.isExpression(body) ? unwrapCall(body) : { call: null, async: false };
-      if (call !== null) {
-        const preconditions = collectPreconditions(node, func);
-        results.push({
-          effect: {
-            type: "invocation",
-            callee: call.getExpression().getText(),
-            args: extractArgs(call),
-            async: async || node.isAsync(),
-            ...preconditions.length > 0 ? { preconditions } : {}
-          },
-          line: startLineOf(node),
-          neverTerminal: false,
-          alwaysRuns: runsOnEveryPath(node, func),
-          node: call
-        });
-      }
-      return;
-    }
     if (import_ts_morph43.Node.isCallExpression(node)) {
-      const parent = node.getParent();
-      if (parent === void 0) {
-        return;
-      }
-      const isArrayElement = import_ts_morph43.Node.isArrayLiteralExpression(parent);
-      const isPropertyValue = import_ts_morph43.Node.isPropertyAssignment(parent) && parent.getInitializer() === node;
-      if (isArrayElement || isPropertyValue) {
-        const preconditions = collectPreconditions(node, func);
-        results.push({
-          effect: {
-            type: "invocation",
-            callee: node.getExpression().getText(),
-            args: extractArgs(node),
-            async: false,
-            ...preconditions.length > 0 ? { preconditions } : {}
-          },
-          line: enclosingStatementLine(node),
-          neverTerminal: true,
-          alwaysRuns: runsOnEveryPath(node, func)
-        });
-      }
+      calls.push(node);
     }
   });
-  return results;
+  calls.sort((a, b) => a.getEnd() - b.getEnd());
+  return calls.map((call) => invocationAt(call, func));
+}
+function invocationAt(call, func) {
+  const preconditions = collectPreconditions(call, func);
+  return {
+    effect: {
+      type: "invocation",
+      callee: call.getExpression().getText(),
+      args: extractArgs(call),
+      async: isAwaited(call),
+      ...preconditions.length > 0 ? { preconditions } : {}
+    },
+    node: call,
+    line: enclosingStatementLine(call),
+    alwaysRuns: runsOnEveryPath(call, func)
+  };
+}
+function isAwaited(call) {
+  let current2 = call.getParent();
+  while (current2 !== void 0 && import_ts_morph43.Node.isParenthesizedExpression(current2)) {
+    current2 = current2.getParent();
+  }
+  return current2 !== void 0 && import_ts_morph43.Node.isAwaitExpression(current2);
 }
 function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   if (recognizers.length === 0) {
@@ -9590,7 +9654,7 @@ function withPreconditions(effect, preconditions) {
   }
   return {
     ...effect,
-    preconditions: preconditions.map(import_extractor3.rawConditionToPredicate)
+    preconditions: preconditions.map(import_extractor4.rawConditionToPredicate)
   };
 }
 function inlineModuleBinding(ident, depth) {
@@ -9647,22 +9711,6 @@ function enclosingStatementLine(node) {
   }
   return startLineOf(node);
 }
-function unwrapCall(node) {
-  if (import_ts_morph43.Node.isAwaitExpression(node)) {
-    const inner = node.getExpression();
-    if (import_ts_morph43.Node.isCallExpression(inner)) {
-      return { call: inner, async: true };
-    }
-    return { call: null, async: false };
-  }
-  if (import_ts_morph43.Node.isParenthesizedExpression(node)) {
-    return unwrapCall(node.getExpression());
-  }
-  if (import_ts_morph43.Node.isCallExpression(node)) {
-    return { call: node, async: false };
-  }
-  return { call: null, async: false };
-}
 
 // src/terminals/index.ts
 var import_ts_morph53 = require("ts-morph");
@@ -11692,10 +11740,26 @@ function makeFallthroughTerminal(func) {
 // src/assembly.ts
 var preconditionsOf = (effect) => effect.type === "invocation" ? effect.preconditions : void 0;
 function firesOn(site, branch) {
-  if (!(0, import_extractor4.guardsHoldOn)(site.preconditions, branch.conditions)) {
+  if (!(0, import_extractor5.guardsHoldOn)(site.preconditions, branch.conditions)) {
     return false;
   }
-  return site.alwaysRuns || (0, import_extractor4.runsBefore)(site.line, branch.terminal.location.end);
+  return site.alwaysRuns || (0, import_extractor5.runsBefore)(site.line, branch.terminal.location.end);
+}
+function writesTerminal(call, terminalNodes) {
+  let current2 = call;
+  for (; ; ) {
+    if (terminalNodes.has(current2)) {
+      return true;
+    }
+    const parent = current2.getParent();
+    if (parent === void 0 || !isReceiverOf(current2, parent)) {
+      return false;
+    }
+    current2 = parent;
+  }
+}
+function isReceiverOf(node, parent) {
+  return (import_ts_morph54.Node.isPropertyAccessExpression(parent) || import_ts_morph54.Node.isElementAccessExpression(parent) || import_ts_morph54.Node.isCallExpression(parent)) && parent.getExpression() === node;
 }
 var isDefaultConditionList = (conditions) => conditions.length === 0 || conditions.every(
   (c) => c.source === "earlyReturn" || c.source === "earlyThrow"
@@ -11835,11 +11899,8 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
   });
   if (invocations.length > 0) {
     const terminalNodes = new Set(terminals.map(({ node }) => node));
-    const terminalLines = new Set(
-      distinctBranches.map((b) => b.terminal.location.start)
-    );
     const sideEffects = invocations.filter(
-      (i) => i.node !== void 0 ? !terminalNodes.has(i.node) : i.neverTerminal || !terminalLines.has(i.line)
+      (i) => !writesTerminal(i.node, terminalNodes)
     );
     for (const branch of distinctBranches) {
       branch.effects = sideEffects.filter(
@@ -11885,9 +11946,9 @@ function createSourceFileLookup(project) {
       if (sf === null) {
         return null;
       }
-      const path15 = sf.getFilePath();
-      const index = functionsByFile.get(path15) ?? indexFunctions(sf);
-      functionsByFile.set(path15, index);
+      const path14 = sf.getFilePath();
+      const index = functionsByFile.get(path14) ?? indexFunctions(sf);
+      functionsByFile.set(path14, index);
       if (location.span !== void 0) {
         const bySpan = index.get(spanKey(location.span));
         if (bySpan !== void 0) {
@@ -11932,397 +11993,47 @@ function indexFunctions(sf) {
   return index;
 }
 
-// src/cache.ts
-var import_node_crypto2 = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-var SCHEMA_VERSION = "6";
-var MAX_ENTRIES = 2;
-var ENTRY_PREFIX = "key-";
-var ENTRY_DIR_NAME = new RegExp(`^${ENTRY_PREFIX}[0-9a-f]{16}$`);
-function createCacheLayer(cacheDir) {
-  if (cacheDir === null) {
-    return {
-      tryHit: async () => null,
-      lookup: async () => ({
-        kind: "miss",
-        diagnostic: { kind: "miss", missReason: "no-manifest" }
-      }),
-      plan: async () => null,
-      write: async () => {
-      }
-    };
-  }
-  return {
-    async tryHit(input) {
-      const result = await this.lookup(input);
-      return result.kind === "hit" ? result.summaries : null;
-    },
-    async lookup(input) {
-      const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await readManifest(import_node_path7.default.join(entryDir, "manifest.json"));
-      if (manifest === null) {
-        return missDiag(await describeAbsentEntry(cacheDir));
-      }
-      const currentTsconfigStamp = await stampTsconfig(input.tsconfigPath);
-      if (!fileStampEquals(manifest.tsconfigStamp, currentTsconfigStamp)) {
-        return missDiag("tsconfig-changed");
-      }
-      const currentFiles = await resolveFileStamps(input);
-      if (!fileStampsEqual(manifest.files, currentFiles)) {
-        return missDiag("files-changed");
-      }
-      await markUsed(entryDir);
-      return {
-        kind: "hit",
-        summaries: manifest.summaries,
-        diagnostic: { kind: "hit" }
-      };
-    },
-    async plan(input) {
-      const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await readManifest(import_node_path7.default.join(entryDir, "manifest.json"));
-      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0 || manifest.owners === void 0) {
-        return null;
-      }
-      const currentTsconfigStamp = await stampTsconfig(input.tsconfigPath);
-      if (!fileStampEquals(manifest.tsconfigStamp, currentTsconfigStamp)) {
-        return null;
-      }
-      await markUsed(entryDir);
-      return buildPlan(manifest, await resolveFileStamps(input));
-    },
-    async write(input, summaries, attribution) {
-      const entryDir = entryDirFor(cacheDir, input);
-      const previous = await readManifest(import_node_path7.default.join(entryDir, "manifest.json"));
-      const tsconfigStamp = await stampTsconfig(input.tsconfigPath);
-      const files = await hashStamps(await resolveFileStamps(input), previous);
-      const manifest = {
-        schemaVersion: SCHEMA_VERSION,
-        adapterPacksDigest: input.adapterPacksDigest,
-        tsconfigStamp,
-        files,
-        summaries,
-        ...attribution === void 0 ? {} : encodeAttribution(attribution)
-      };
-      await import_promises2.default.mkdir(entryDir, { recursive: true });
-      await import_promises2.default.writeFile(
-        import_node_path7.default.join(entryDir, "manifest.json"),
-        JSON.stringify(manifest)
-      );
-      await evictOldEntries(cacheDir, entryDir);
-    }
-  };
-}
-async function buildPlan(manifest, currentStamps) {
-  const stored = new Map(manifest.files.map((f) => [f.path, f]));
-  const current2 = new Map(currentStamps.map((f) => [f.path, f]));
-  const changed = /* @__PURE__ */ new Set();
-  const removed = /* @__PURE__ */ new Set();
-  for (const p of stored.keys()) {
-    if (!current2.has(p)) {
-      removed.add(p);
-    }
-  }
-  const toVerify = [];
-  for (const [p, stamp] of current2) {
-    const before = stored.get(p);
-    if (before === void 0) {
-      changed.add(p);
-    } else if (!fileStampEquals(before, stamp)) {
-      if (before.contentHash === void 0) {
-        changed.add(p);
-      } else {
-        toVerify.push(p);
-      }
-    }
+// src/contract.ts
+var import_ts_morph56 = require("ts-morph");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
+function extractDeclaredBody(node) {
+  if (node === void 0) {
+    return null;
   }
-  await Promise.all(
-    toVerify.map(async (p) => {
-      const hash = await hashFile(p);
-      if (hash === null || hash !== stored.get(p)?.contentHash) {
-        changed.add(p);
-      }
-    })
-  );
-  const roots = /* @__PURE__ */ new Map();
-  const rootNames = manifest.roots ?? [];
-  const depPaths = manifest.depPaths ?? [];
-  let rootsDeclined = 0;
-  rootNames.forEach((rootPath, i) => {
-    const meta = manifest.rootMeta?.[i];
-    if (meta === void 0) {
-      return;
-    }
-    if (!meta.cacheable) {
-      rootsDeclined += 1;
-    }
-    roots.set(rootPath, {
-      path: rootPath,
-      cacheable: meta.cacheable,
-      deps: meta.deps.flatMap((d) => {
-        const p = depPaths[d];
-        return p === void 0 ? [] : [p];
-      }),
-      claims: meta.claims,
-      mountPrefixes: meta.mountPrefixes,
-      packs: meta.packs
-    });
-  });
-  const validRoots = /* @__PURE__ */ new Set();
-  for (const [rootPath, record2] of roots) {
-    if (!record2.cacheable || !current2.has(rootPath)) {
-      continue;
-    }
-    if (changed.has(rootPath)) {
-      continue;
-    }
-    const depMoved = record2.deps.some((d) => changed.has(d) || removed.has(d));
-    if (!depMoved) {
-      validRoots.add(rootPath);
-    }
+  if (!import_ts_morph56.Node.isCallExpression(node)) {
+    return null;
   }
-  const owners = manifest.owners ?? [];
-  return {
-    changed,
-    removed,
-    roots,
-    validRoots,
-    rootsDeclined,
-    reuse(valid) {
-      const summaries = [];
-      const reusedOwners = [];
-      manifest.summaries.forEach((summary, i) => {
-        const ownerPaths = (owners[i] ?? []).flatMap((o) => {
-          const p = rootNames[o];
-          return p === void 0 ? [] : [p];
-        });
-        if (ownerPaths.some((p) => valid.has(p))) {
-          summaries.push(summary);
-          reusedOwners.push(ownerPaths.filter((p) => valid.has(p)));
-        }
-      });
-      return { summaries, owners: reusedOwners };
-    },
-    allSummaries() {
-      return manifest.summaries;
-    },
-    attribution() {
-      return {
-        roots: [...roots.values()],
-        owners: owners.map(
-          (ownerIds) => ownerIds.flatMap((o) => {
-            const p = rootNames[o];
-            return p === void 0 ? [] : [p];
-          })
-        )
-      };
-    }
-  };
-}
-function encodeAttribution(attribution) {
-  const roots = attribution.roots.map((r) => r.path);
-  const rootIndex = new Map(roots.map((p, i) => [p, i]));
-  const depIndex = /* @__PURE__ */ new Map();
-  const depPaths = [];
-  const depIdOf = (p) => {
-    const existing = depIndex.get(p);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const id = depPaths.length;
-    depPaths.push(p);
-    depIndex.set(p, id);
-    return id;
-  };
-  const rootMeta = attribution.roots.map((r) => ({
-    cacheable: r.cacheable,
-    deps: r.deps.map(depIdOf),
-    claims: r.claims,
-    mountPrefixes: r.mountPrefixes,
-    packs: r.packs
-  }));
-  const owners = attribution.owners.map(
-    (ownerPaths) => ownerPaths.flatMap((p) => {
-      const i = rootIndex.get(p);
-      return i === void 0 ? [] : [i];
-    })
-  );
-  return { roots, rootMeta, depPaths, owners };
-}
-async function hashStamps(stamps, previous) {
-  const before = new Map((previous?.files ?? []).map((f) => [f.path, f]));
-  return Promise.all(
-    stamps.map(async (stamp) => {
-      const prior = before.get(stamp.path);
-      if (prior !== void 0 && prior.contentHash !== void 0 && fileStampEquals(prior, stamp)) {
-        return { ...stamp, contentHash: prior.contentHash };
-      }
-      const contentHash = await hashFile(stamp.path);
-      return contentHash === null ? stamp : { ...stamp, contentHash };
-    })
-  );
-}
-async function hashFile(filePath) {
-  try {
-    const content = await import_promises2.default.readFile(filePath);
-    return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex").slice(0, 16);
-  } catch {
+  const typeArgs = node.getTypeArguments();
+  if (typeArgs.length === 0) {
     return null;
   }
+  return shapeFromNodeType(typeArgs[0]);
 }
-async function describeAbsentEntry(cacheDir) {
-  try {
-    const entries = await import_promises2.default.readdir(cacheDir, { withFileTypes: true });
-    return entries.some((e) => e.isDirectory() && isEntryDir(e.name)) ? "key-changed" : "no-manifest";
-  } catch {
-    return "no-manifest";
+function resolveHandlerPropNode(func) {
+  const parent = func.getParent();
+  if (parent === void 0) {
+    return null;
   }
-}
-function entryDirFor(cacheDir, input) {
-  const key = [
-    SCHEMA_VERSION,
-    input.adapterPacksDigest,
-    input.tsconfigPath ?? ""
-  ].join(" ");
-  const name = (0, import_node_crypto2.createHash)("sha256").update(key).digest("hex").slice(0, 16);
-  return import_node_path7.default.join(cacheDir, `${ENTRY_PREFIX}${name}`);
-}
-function isEntryDir(name) {
-  return ENTRY_DIR_NAME.test(name);
-}
-async function markUsed(entryDir) {
-  const now = /* @__PURE__ */ new Date();
-  try {
-    await import_promises2.default.utimes(entryDir, now, now);
-  } catch {
+  if (import_ts_morph56.Node.isPropertyAssignment(parent)) {
+    return parent;
   }
-}
-async function evictOldEntries(cacheDir, keepDir) {
-  try {
-    await import_promises2.default.rm(import_node_path7.default.join(cacheDir, "manifest.json"), { force: true });
-    const entries = await import_promises2.default.readdir(cacheDir, { withFileTypes: true });
-    const dirs = await Promise.all(
-      entries.filter((e) => e.isDirectory() && isEntryDir(e.name)).map(async (e) => {
-        const dir = import_node_path7.default.join(cacheDir, e.name);
-        const stat = await import_promises2.default.stat(dir);
-        return { dir, mtimeMs: stat.mtimeMs };
-      })
-    );
-    const doomed = dirs.filter((d) => d.dir !== keepDir).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(MAX_ENTRIES - 1);
-    await Promise.all(
-      doomed.map((d) => import_promises2.default.rm(d.dir, { recursive: true, force: true }))
-    );
-  } catch {
+  if (import_ts_morph56.Node.isMethodDeclaration(func)) {
+    return func;
   }
+  return null;
 }
-function missDiag(reason) {
-  return {
-    kind: "miss",
-    diagnostic: { kind: "miss", missReason: reason }
-  };
-}
-async function readManifest(manifestPath) {
-  try {
-    const raw = await import_promises2.default.readFile(manifestPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
+function findRouterCall(unit) {
+  const func = unit.func;
+  const propNode = func === null ? null : resolveHandlerPropNode(func);
+  if (propNode === null) {
     return null;
   }
-}
-async function stampTsconfig(tsconfigPath) {
-  if (tsconfigPath === void 0) {
+  const handlersObj = propNode.getParent();
+  if (handlersObj === void 0 || !import_ts_morph56.Node.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
-  try {
-    const stat = await import_promises2.default.stat(tsconfigPath);
-    return { path: tsconfigPath, mtimeMs: stat.mtimeMs, size: stat.size };
-  } catch {
-    return null;
-  }
-}
-async function resolveFileStamps(input) {
-  if (input.files !== void 0) {
-    return stampPaths(input.files);
-  }
-  if (input.project !== void 0) {
-    return stampProjectFiles(input.project);
-  }
-  return [];
-}
-async function stampProjectFiles(project) {
-  const files = project.getSourceFiles().filter((sf) => !sf.isDeclarationFile()).map((sf) => sf.getFilePath());
-  return stampPaths(files);
-}
-async function stampPaths(paths) {
-  const files = paths;
-  const stamped = await Promise.all(
-    files.map(async (p) => {
-      try {
-        const stat = await import_promises2.default.stat(p);
-        return { path: p, mtimeMs: stat.mtimeMs, size: stat.size };
-      } catch {
-        return { path: p, mtimeMs: -1, size: -1 };
-      }
-    })
-  );
-  stamped.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  return stamped;
-}
-function fileStampsEqual(a, b) {
-  return a.length === b.length && a.every((s, i) => fileStampEquals(s, b[i]));
-}
-function fileStampEquals(a, b) {
-  if (a === null && b === null) {
-    return true;
-  }
-  if (a === null || b === null) {
-    return false;
-  }
-  return a.path === b.path && a.mtimeMs === b.mtimeMs && a.size === b.size;
-}
-
-// src/contract.ts
-var import_ts_morph56 = require("ts-morph");
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
-function extractDeclaredBody(node) {
-  if (node === void 0) {
-    return null;
-  }
-  if (!import_ts_morph56.Node.isCallExpression(node)) {
-    return null;
-  }
-  const typeArgs = node.getTypeArguments();
-  if (typeArgs.length === 0) {
-    return null;
-  }
-  return shapeFromNodeType(typeArgs[0]);
-}
-function resolveHandlerPropNode(func) {
-  const parent = func.getParent();
-  if (parent === void 0) {
-    return null;
-  }
-  if (import_ts_morph56.Node.isPropertyAssignment(parent)) {
-    return parent;
-  }
-  if (import_ts_morph56.Node.isMethodDeclaration(func)) {
-    return func;
-  }
-  return null;
-}
-function findRouterCall(unit) {
-  const func = unit.func;
-  const propNode = func === null ? null : resolveHandlerPropNode(func);
-  if (propNode === null) {
-    return null;
-  }
-  const handlersObj = propNode.getParent();
-  if (handlersObj === void 0 || !import_ts_morph56.Node.isObjectLiteralExpression(handlersObj)) {
-    return null;
-  }
-  const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !import_ts_morph56.Node.isCallExpression(routerCall)) {
+  const routerCall = handlersObj.getParent();
+  if (routerCall === void 0 || !import_ts_morph56.Node.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -12424,7 +12135,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   }
   const responses = [];
   let method;
-  let path15;
+  let path14;
   for (const prop of endpointNode.getProperties()) {
     if (!import_ts_morph56.Node.isPropertyAssignment(prop)) {
       continue;
@@ -12439,7 +12150,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
       if (val !== void 0 && import_ts_morph56.Node.isStringLiteral(val)) {
-        path15 = val.getLiteralValue();
+        path14 = val.getLiteralValue();
       }
     }
     if (propName === pattern.responseExtraction.property) {
@@ -12463,10 +12174,10 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   if (responses.length === 0) {
     return null;
   }
-  const boundaryBinding = method !== void 0 || path15 !== void 0 ? (0, import_behavioral_ir4.restBinding)({
+  const boundaryBinding = method !== void 0 || path14 !== void 0 ? (0, import_behavioral_ir5.restBinding)({
     transport: "http",
     method: method ?? null,
-    path: path15 ?? null,
+    path: path14 ?? null,
     recognition: framework
   }) : null;
   return {
@@ -12664,7 +12375,7 @@ function parameterName(segment, convention) {
 // src/discovery/graphqlClientConstruction.ts
 var import_picomatch2 = __toESM(require("picomatch"), 1);
 var import_ts_morph57 = require("ts-morph");
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
 function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const scopes = compileOperationScopes(packs);
   const sole = soleGraphqlClientRef(
@@ -12674,10 +12385,10 @@ function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const soleClient = sole !== null ? workspace !== null ? { ...sole, workspace } : sole : null;
   let registry = null;
   for (const summary of summaries) {
-    if (!(0, import_behavioral_ir5.isGraphqlOperationBinding)(summary.identity.boundaryBinding)) {
+    if (!(0, import_behavioral_ir6.isGraphqlOperationBinding)(summary.identity.boundaryBinding)) {
       continue;
     }
-    const existing = (0, import_behavioral_ir5.readGraphqlMetadata)(summary) ?? {};
+    const existing = (0, import_behavioral_ir6.readGraphqlMetadata)(summary) ?? {};
     const scoped = scopedWorkspaceFor(summary.location.file, scopes);
     const client = scoped !== null ? { uri: null, uriRef: null, workspace: scoped } : soleClient;
     const dangling = (existing.unresolvedFragments?.length ?? 0) > 0;
@@ -12687,7 +12398,7 @@ function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
     if (dangling && registry === null) {
       registry = fragmentRegistryStatus(sourceFiles, packs);
     }
-    summary.metadata = (0, import_behavioral_ir5.withGraphqlMetadata)(summary.metadata, {
+    summary.metadata = (0, import_behavioral_ir6.withGraphqlMetadata)(summary.metadata, {
       ...existing,
       ...client !== null ? { client } : {},
       ...dangling && registry !== null ? { fragmentRegistry: registry } : {}
@@ -13099,8 +12810,8 @@ function noteExpanded(expanded, readings, discovery) {
     const paths = new Set(match.registrations.map((one) => one.pathTemplate));
     const methods = expanded.get(reading.declarationId) ?? /* @__PURE__ */ new Set();
     for (const sink of reading.helper.sinks) {
-      const path15 = sink.arguments[0];
-      if (sink.method !== null && path15?.as === "text" && paths.has(path15.text)) {
+      const path14 = sink.arguments[0];
+      if (sink.method !== null && path14?.as === "text" && paths.has(path14.text)) {
         methods.add(sink.method);
       }
     }
@@ -13689,7 +13400,7 @@ function scalarOrRef(node) {
 }
 
 // src/moduleInit.ts
-var import_extractor5 = require("@suss/extractor");
+var import_extractor6 = require("@suss/extractor");
 function moduleInitName(sourceFile) {
   return sourceFile.getBaseName();
 }
@@ -13697,44 +13408,15 @@ function moduleInitSummary(sourceFile, effects, options) {
   if (effects.length === 0) {
     return null;
   }
-  const end = sourceFile.getEnd();
-  const raw = {
-    identity: {
+  return (0, import_extractor6.assembleSummary)(
+    (0, import_extractor6.moduleInitStructure)({
       name: moduleInitName(sourceFile),
-      kind: "module-init",
       file: sourceFile.getFilePath(),
-      range: { start: 0, end },
-      exportName: null,
-      exportPath: null
-    },
-    boundaryBinding: null,
-    parameters: [],
-    branches: [
-      {
-        conditions: [],
-        terminal: {
-          kind: "void",
-          statusCode: null,
-          body: null,
-          exceptionType: null,
-          message: null,
-          component: null,
-          renderTree: null,
-          delegateTarget: null,
-          emitEvent: null,
-          location: { start: 0, end }
-        },
-        effects: [],
-        extraEffects: effects,
-        location: { start: 0, end },
-        isDefault: true
-      }
-    ],
-    unmatchedReturns: 0,
-    dependencyCalls: [],
-    declaredContract: null
-  };
-  return (0, import_extractor5.assembleSummary)(raw, options);
+      range: { start: 0, end: sourceFile.getEnd() },
+      effects
+    }),
+    options
+  );
 }
 
 // src/referencedFiles.ts
@@ -13882,9 +13564,9 @@ function deriveBoundaryEffects(summaries, facts) {
 
 // src/resolve/reachableClosure.ts
 var import_ts_morph62 = require("ts-morph");
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
-var import_extractor6 = require("@suss/extractor");
+var import_extractor7 = require("@suss/extractor");
 var reachablePack = {
   name: "reachable",
   languages: ["typescript"],
@@ -13906,6 +13588,12 @@ var reachablePack = {
 function nodeKey(func) {
   return offsetKeyOf(func);
 }
+function targetOf(node) {
+  return {
+    file: node.getSourceFile().getFilePath(),
+    span: { start: node.getStart(), end: node.getEnd() }
+  };
+}
 function resolveCallee(call, calleeName, scan) {
   if (!import_ts_morph62.Node.isCallExpression(call)) {
     return null;
@@ -13930,19 +13618,42 @@ function resolveCallee(call, calleeName, scan) {
     if (sources.length > 1) {
       return {
         kind: "stopped",
-        stop: { callee: calleeName, reason: "multipleSources" }
+        stop: { callee: calleeName, reason: "multipleSources" },
+        declaration: declarationToReport(declarations, calleeName, scan)
       };
     }
   }
+  const reason = classifyStop(declarations, scan.scanning);
+  const parameterIndex = reason === "callerSupplied" ? parameterIndexOf(declarations, scan.scanning) : void 0;
   return {
     kind: "stopped",
-    stop: {
-      callee: calleeName,
-      reason: classifyStop(declarationsBehind(symbol), scan.scanning)
-    }
+    stop: { callee: calleeName, reason },
+    declaration: declarationToReport(declarations, calleeName, scan),
+    ...parameterIndex === void 0 ? {} : { parameterIndex }
   };
 }
-function resolveJsxReference(node) {
+function declarationToReport(declarations, calleeName, scan) {
+  const first = declarations[0];
+  if (first === void 0) {
+    return null;
+  }
+  const sources = scan.sourceDeclarationsBehind?.(first) ?? [first];
+  const only = sources.length === 1 ? sources[0] : void 0;
+  if (only === void 0 || only === first) {
+    return first;
+  }
+  return resolveDecl(only, calleeName)?.func ?? only;
+}
+function declaredAtOf(outcome) {
+  if (outcome.kind === "followed") {
+    return targetOf(outcome.candidate.func);
+  }
+  return outcome.declaration === null ? null : targetOf(outcome.declaration);
+}
+function passedPositionKey(target, position) {
+  return `${offsetKeyFor(target.file, target.span)}#${position}`;
+}
+function resolveJsxReference(node, scan) {
   if (!import_ts_morph62.Node.isJsxOpeningElement(node) && !import_ts_morph62.Node.isJsxSelfClosingElement(node)) {
     return null;
   }
@@ -13962,7 +13673,8 @@ function resolveJsxReference(node) {
     tag: name,
     outcome: {
       kind: "stopped",
-      stop: { callee: name, reason: classifyStop(declarations) }
+      stop: { callee: name, reason: classifyStop(declarations) },
+      declaration: declarationToReport(declarations, name, scan)
     }
   };
 }
@@ -13970,11 +13682,15 @@ function collectReachable(func, scan) {
   const inFunc = { ...scan, scanning: func };
   const candidates = [];
   const stops = [];
+  const placements = new import_behavioral_ir7.TargetPlacements();
+  const parameterCalls = [];
+  const passedPositions = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
+  const parameterCallsSeen = /* @__PURE__ */ new Set();
   const record2 = (outcome) => {
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.stop.reason}:${outcome.stop.callee}`;
-      if (!seen.has(stopKey) && worthRecording(outcome.stop.reason)) {
+      if (!seen.has(stopKey) && (0, import_behavioral_ir3.worthRecording)(outcome.stop.reason)) {
         seen.add(stopKey);
         stops.push(outcome.stop);
       }
@@ -13987,8 +13703,28 @@ function collectReachable(func, scan) {
     seen.add(key);
     candidates.push(outcome.candidate);
   };
+  const recordPassedArgs = (call, calleeText, calleeOutcome) => {
+    if (!import_ts_morph62.Node.isCallExpression(call)) {
+      return;
+    }
+    const calleeTarget = declaredAtOf(calleeOutcome);
+    call.getArguments().forEach((arg, position) => {
+      if (!import_ts_morph62.Node.isIdentifier(arg)) {
+        return;
+      }
+      const resolved = functionTargetOf(arg);
+      if (resolved === null) {
+        return;
+      }
+      record2({ kind: "followed", candidate: resolved });
+      placements.placeArg(calleeText, position, targetOf(resolved.func));
+      if (calleeTarget !== null) {
+        passedPositions.add(passedPositionKey(calleeTarget, position));
+      }
+    });
+  };
   func.forEachDescendant((node) => {
-    const jsx = resolveJsxReference(node);
+    const jsx = resolveJsxReference(node, inFunc);
     if (jsx !== null) {
       record2(jsx.outcome);
       return;
@@ -14002,8 +13738,24 @@ function collectReachable(func, scan) {
       return;
     }
     record2(outcome);
+    placements.place(calleeText, declaredAtOf(outcome));
+    recordPassedArgs(node, calleeText, outcome);
+    if (outcome.kind === "stopped" && outcome.stop.reason === "callerSupplied" && outcome.parameterIndex !== void 0 && !parameterCallsSeen.has(calleeText)) {
+      parameterCallsSeen.add(calleeText);
+      parameterCalls.push({
+        callee: calleeText,
+        parameterIndex: outcome.parameterIndex
+      });
+    }
   });
-  return { candidates, stops };
+  return {
+    candidates,
+    stops,
+    targets: placements.targets,
+    argTargets: placements.argTargets,
+    parameterCalls,
+    passedPositions
+  };
 }
 function normalizeCallee(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -14022,11 +13774,11 @@ function extractReachableSummary(candidate, options, recognizers) {
     void 0,
     recognizers.resolveWrittenValue
   );
-  raw.boundaryBinding = (0, import_behavioral_ir6.functionCallBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir7.functionCallBinding)({
     transport: "in-process",
     recognition: "reachable"
   });
-  return (0, import_extractor6.assembleSummary)(raw, options);
+  return (0, import_extractor7.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"))]),
@@ -14078,6 +13830,10 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
   const seedKeys = /* @__PURE__ */ new Set();
   const scanned = /* @__PURE__ */ new Set();
   const stopsByKey = /* @__PURE__ */ new Map();
+  const targetsByKey = /* @__PURE__ */ new Map();
+  const argTargetsByKey = /* @__PURE__ */ new Map();
+  const parameterCallsByKey = /* @__PURE__ */ new Map();
+  const passedPositions = /* @__PURE__ */ new Set();
   const summariesByKey = /* @__PURE__ */ new Map();
   const reachedFrom = /* @__PURE__ */ new Map();
   for (const seed of seeds) {
@@ -14122,9 +13878,17 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       const cameFrom = reachedFrom.get(key);
       const scan = {
         ...recognizers.resolveCallableSources === void 0 ? {} : { resolveCallableSources: recognizers.resolveCallableSources },
+        ...recognizers.sourceDeclarationsBehind === void 0 ? {} : { sourceDeclarationsBehind: recognizers.sourceDeclarationsBehind },
         ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
       };
-      const { candidates, stops } = scanWithRecording(
+      const {
+        candidates,
+        stops,
+        targets,
+        argTargets,
+        parameterCalls,
+        passedPositions: scanPassedPositions
+      } = scanWithRecording(
         key,
         facts,
         () => collectReachable(source.func, scan)
@@ -14132,6 +13896,14 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       if (stops.length > 0) {
         stopsByKey.set(key, stops);
       }
+      targetsByKey.set(key, targets);
+      argTargetsByKey.set(key, argTargets);
+      if (parameterCalls.length > 0) {
+        parameterCallsByKey.set(key, parameterCalls);
+      }
+      for (const position of scanPassedPositions) {
+        passedPositions.add(position);
+      }
       for (const candidate of candidates) {
         const calleeKey = nodeKey(candidate.func);
         if (!functionByKey.has(calleeKey)) {
@@ -14171,6 +13943,15 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
     reached.push(summary);
   }
   recordStops(stopsByKey, summariesByKey, options);
+  recordTargets(targetsByKey, summariesByKey);
+  recordArgTargets(argTargetsByKey, summariesByKey);
+  recordCalleeParameters(parameterCallsByKey, summariesByKey);
+  recordParameterGaps(
+    parameterCallsByKey,
+    summariesByKey,
+    passedPositions,
+    options
+  );
   return [...seeds, ...reached];
 }
 function scanWithRecording(key, facts, fn) {
@@ -14198,7 +13979,91 @@ function recordStops(stopsByKey, summariesByKey, options) {
   }
   for (const [key, stops] of stopsByKey) {
     for (const summary of summariesByKey.get(key) ?? []) {
-      summary.gaps.push(...stops.map(unfollowedCallGap));
+      summary.gaps.push(...stops.map(import_behavioral_ir3.unfollowedCallGap));
+    }
+  }
+}
+function recordTargets(targetsByKey, summariesByKey) {
+  for (const [key, targets] of targetsByKey) {
+    for (const summary of summariesByKey.get(key) ?? []) {
+      for (const transition of summary.transitions) {
+        for (const effect of transition.effects) {
+          if (effect.type !== "invocation") {
+            continue;
+          }
+          const target = targets.get(normalizeCallee(effect.callee));
+          if (target !== void 0) {
+            effect.declaredAt = target;
+          }
+        }
+      }
+    }
+  }
+}
+function recordArgTargets(argTargetsByKey, summariesByKey) {
+  for (const [key, argTargets] of argTargetsByKey) {
+    for (const summary of summariesByKey.get(key) ?? []) {
+      for (const transition of summary.transitions) {
+        for (const effect of transition.effects) {
+          if (effect.type !== "invocation") {
+            continue;
+          }
+          const byPosition = argTargets.get(normalizeCallee(effect.callee));
+          if (byPosition === void 0) {
+            continue;
+          }
+          const argsDeclaredAt = {};
+          for (const [position, target] of byPosition) {
+            argsDeclaredAt[position] = target;
+          }
+          if (Object.keys(argsDeclaredAt).length > 0) {
+            effect.argsDeclaredAt = argsDeclaredAt;
+          }
+        }
+      }
+    }
+  }
+}
+function recordCalleeParameters(parameterCallsByKey, summariesByKey) {
+  for (const [key, parameterCalls] of parameterCallsByKey) {
+    const byCallee = new Map(
+      parameterCalls.map(({ callee, parameterIndex }) => [
+        callee,
+        parameterIndex
+      ])
+    );
+    for (const summary of summariesByKey.get(key) ?? []) {
+      for (const transition of summary.transitions) {
+        for (const effect of transition.effects) {
+          if (effect.type !== "invocation") {
+            continue;
+          }
+          const parameterIndex = byCallee.get(normalizeCallee(effect.callee));
+          if (parameterIndex !== void 0) {
+            effect.calleeParameter = parameterIndex;
+          }
+        }
+      }
+    }
+  }
+}
+function recordParameterGaps(parameterCallsByKey, summariesByKey, passedPositions, options) {
+  if (options?.gapHandling === "silent") {
+    return;
+  }
+  for (const [key, parameterCalls] of parameterCallsByKey) {
+    const unbound = parameterCalls.filter(
+      ({ parameterIndex }) => !passedPositions.has(`${key}#${parameterIndex}`)
+    );
+    if (unbound.length === 0) {
+      continue;
+    }
+    for (const summary of summariesByKey.get(key) ?? []) {
+      summary.gaps.push(
+        ...unbound.map(
+          ({ callee }) => (0, import_behavioral_ir3.unfollowedCallGap)({ callee, reason: "unboundParameter" })
+        )
+      );
     }
   }
 }
@@ -14933,9 +14798,8 @@ function readArrayLiteralText(node) {
 }
 
 // src/summaryIdentity.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
 function workspaceRootFor(anchor) {
   return namedPackageDirAbove(anchor) ?? import_node_path8.default.resolve(anchor);
 }
@@ -14950,32 +14814,6 @@ function workspaceNameFor(root) {
   const folder = import_node_path8.default.basename(import_node_path8.default.resolve(root));
   return folder.length > 0 ? folder : null;
 }
-function namedPackageDirAbove(start) {
-  let at = import_node_path8.default.resolve(start);
-  for (let up = 0; up < 12; up += 1) {
-    if (packageNameAt(at) !== null) {
-      return at;
-    }
-    const parent = import_node_path8.default.dirname(at);
-    if (parent === at) {
-      break;
-    }
-    at = parent;
-  }
-  return null;
-}
-function packageNameAt(dir) {
-  try {
-    const manifest = JSON.parse(
-      import_node_fs4.default.readFileSync(import_node_path8.default.join(dir, "package.json"), "utf8")
-    );
-    if (typeof manifest.name === "string" && manifest.name.length > 0) {
-      return manifest.name;
-    }
-  } catch {
-  }
-  return null;
-}
 function nameSummaries(summaries, args) {
   for (const summary of summaries) {
     const file = relativeFile(summary.location.file, args.projectRoot);
@@ -14984,8 +14822,8 @@ function nameSummaries(summaries, args) {
     }
     summary.identity.id = idFor(args.workspace, file, summary);
   }
-  (0, import_behavioral_ir7.disambiguateSummaryIds)(summaries);
-  nameWhatEachCallReaches(summaries);
+  (0, import_behavioral_ir8.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir8.linkCallsToSummaries)(summaries);
 }
 function relativeFile(file, projectRoot) {
   if (projectRoot === void 0 || !import_node_path8.default.isAbsolute(file)) {
@@ -14995,193 +14833,39 @@ function relativeFile(file, projectRoot) {
   return relative.startsWith("..") ? file : relative;
 }
 function idFor(workspace, file, summary) {
-  return (0, import_behavioral_ir7.summaryIdFromParts)({
+  return (0, import_behavioral_ir8.summaryIdFromParts)({
     workspace: workspace ?? void 0,
     file,
     name: summary.identity.name,
     exportPath: summary.identity.exportPath
   });
 }
-function nameWhatEachCallReaches(summaries) {
-  const byName = /* @__PURE__ */ new Map();
-  const byFileAndName = /* @__PURE__ */ new Map();
-  const remember = (index, key, summary) => {
-    const found = index.get(key);
-    if (found === void 0) {
-      index.set(key, [summary]);
-      return;
-    }
-    found.push(summary);
-  };
-  for (const summary of summaries) {
-    if (summary.identity.nameKind === "label") {
-      continue;
-    }
-    remember(byName, summary.identity.name, summary);
-    remember(
-      byFileAndName,
-      `${summary.location.file}::${summary.identity.name}`,
-      summary
-    );
-  }
-  const onlyAnswer = (index, key) => {
-    const found = index.get(key) ?? [];
-    return found.length === 1 ? found[0] : null;
-  };
-  for (const summary of summaries) {
-    for (const transition of summary.transitions) {
-      for (const effect of transition.effects) {
-        if (effect.type !== "invocation") {
-          continue;
-        }
-        const called = effect.callee.split(".").pop() ?? effect.callee;
-        const reached = onlyAnswer(byFileAndName, `${summary.location.file}::${called}`) ?? onlyAnswer(byName, called);
-        if (reached?.identity.id !== void 0) {
-          effect.summary = reached.identity.id;
-        }
-      }
-    }
-  }
-}
 
 // src/timing.ts
-function createTimer() {
-  const phases = /* @__PURE__ */ new Map();
-  const start = performance.now();
-  function record2(label, deltaMs) {
-    const existing = phases.get(label);
-    if (existing === void 0) {
-      phases.set(label, { durationMs: deltaMs, calls: 1 });
-    } else {
-      existing.durationMs += deltaMs;
-      existing.calls += 1;
-    }
-  }
-  return {
-    time(label, fn) {
-      const t0 = performance.now();
-      try {
-        return fn();
-      } finally {
-        record2(label, performance.now() - t0);
-      }
-    },
-    async timeAsync(label, fn) {
-      const t0 = performance.now();
-      try {
-        return await fn();
-      } finally {
-        record2(label, performance.now() - t0);
-      }
-    },
-    report() {
-      const totalMs = performance.now() - start;
-      const ordered = [...phases.entries()].map(([label, s]) => ({
-        label,
-        durationMs: s.durationMs,
-        calls: s.calls
-      })).sort((a, b) => b.durationMs - a.durationMs);
-      return { totalMs, phases: ordered };
-    }
-  };
-}
+var import_extractor8 = require("@suss/extractor");
 
 // src/version.ts
-var import_node_crypto3 = require("crypto");
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_module = require("module");
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_extractor9 = require("@suss/extractor");
+var import_extractor10 = require("@suss/extractor");
 var import_meta = {};
 var ADAPTER_VERSION = "0.2.1";
-var ANALYSIS_PACKAGES = [
-  "@suss/extractor",
-  "@suss/resolution",
-  "@suss/datalog",
-  "@suss/behavioral-ir"
-];
-var SOURCE_STAMP = { kind: "source" };
-var cachedCodeStamp = null;
-function adapterCodeStamp() {
-  if (cachedCodeStamp !== null) {
-    return cachedCodeStamp;
-  }
-  cachedCodeStamp = readAdapterCodeStamp();
-  return cachedCodeStamp;
-}
-function readAdapterCodeStamp() {
-  try {
-    const selfPath = (0, import_node_url.fileURLToPath)(import_meta.url);
-    const hash = computeDistHashFrom(import_node_path9.default.dirname(selfPath));
-    return hash.length > 0 ? { kind: "bundle", hash } : SOURCE_STAMP;
-  } catch {
-    return SOURCE_STAMP;
-  }
-}
-function computeDistHashFrom(dir) {
-  const candidates = [import_node_path9.default.join(dir, "index.js"), import_node_path9.default.join(dir, "index.cjs")];
-  for (const candidate of candidates) {
-    if (!import_node_fs5.default.existsSync(candidate)) {
-      continue;
-    }
-    return computeContentHash([candidate, ...analysisBundles()]);
-  }
-  return "";
-}
-function computeContentHash(paths) {
-  if (paths.length === 0) {
-    return "";
-  }
-  const hash = (0, import_node_crypto3.createHash)("sha256");
-  for (const file of paths) {
-    try {
-      hash.update(import_node_fs5.default.readFileSync(file));
-    } catch {
-      return "";
-    }
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-function projectFileStamp(paths) {
-  if (paths.length === 0) {
-    return "none";
-  }
-  const hash = (0, import_node_crypto3.createHash)("sha256");
-  for (const file of [...paths].sort()) {
-    hash.update(file);
-    hash.update("\0");
-    try {
-      hash.update(import_node_fs5.default.readFileSync(file));
-    } catch {
-      hash.update("absent");
-    }
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-function analysisBundles() {
-  const require2 = (0, import_node_module.createRequire)(import_meta.url);
-  const found = [];
-  for (const name of ANALYSIS_PACKAGES) {
-    try {
-      found.push(require2.resolve(name));
-    } catch {
-    }
-  }
-  return found;
-}
+var stamp = (0, import_extractor9.createAdapterStamp)({
+  moduleUrl: import_meta.url,
+  version: ADAPTER_VERSION
+});
 function computeAdapterPacksDigest(packVersions) {
-  const sortedPacks = [...packVersions].map((p) => `${p.name}@${p.version ?? "unset"}`).sort();
-  const stamp = adapterCodeStamp();
-  const adapterStamp = stamp.kind === "bundle" ? `adapter@${ADAPTER_VERSION}+${stamp.hash}` : `adapter@${ADAPTER_VERSION}+source`;
-  return `${adapterStamp}|${sortedPacks.join(",")}`;
+  return stamp.packsDigest(packVersions);
+}
+function declineWhenRunFromSource(cacheDir) {
+  return stamp.declineWhenRunFromSource(cacheDir);
 }
 
 // src/workspacePatterns.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 function readJson(filePath) {
   try {
-    return JSON.parse(import_node_fs6.default.readFileSync(filePath, "utf8"));
+    return JSON.parse(import_node_fs3.default.readFileSync(filePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -15208,7 +14892,7 @@ function pnpmWorkspaceGlobs(yamlText) {
   return globs;
 }
 function workspaceGlobsAt(dir) {
-  const pkg = readJson(import_node_path10.default.join(dir, "package.json"));
+  const pkg = readJson(import_node_path9.default.join(dir, "package.json"));
   if (typeof pkg === "object" && pkg !== null && "workspaces" in pkg) {
     const ws = pkg.workspaces;
     if (Array.isArray(ws)) {
@@ -15220,10 +14904,10 @@ function workspaceGlobsAt(dir) {
       );
     }
   }
-  const pnpmPath = import_node_path10.default.join(dir, "pnpm-workspace.yaml");
-  if (import_node_fs6.default.existsSync(pnpmPath)) {
+  const pnpmPath = import_node_path9.default.join(dir, "pnpm-workspace.yaml");
+  if (import_node_fs3.default.existsSync(pnpmPath)) {
     try {
-      return pnpmWorkspaceGlobs(import_node_fs6.default.readFileSync(pnpmPath, "utf8"));
+      return pnpmWorkspaceGlobs(import_node_fs3.default.readFileSync(pnpmPath, "utf8"));
     } catch {
       return null;
     }
@@ -15232,14 +14916,14 @@ function workspaceGlobsAt(dir) {
 }
 function isDirectory(candidate) {
   try {
-    return import_node_fs6.default.statSync(candidate).isDirectory();
+    return import_node_fs3.default.statSync(candidate).isDirectory();
   } catch {
     return false;
   }
 }
 function subdirectoriesOf(dir) {
   try {
-    return import_node_fs6.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
+    return import_node_fs3.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
   } catch {
     return [];
   }
@@ -15257,13 +14941,13 @@ function directoriesMatchingGlob(root, glob) {
       for (const dir of current2) {
         for (const entry of subdirectoriesOf(dir)) {
           if (pattern.test(entry)) {
-            next.push(import_node_path10.default.join(dir, entry));
+            next.push(import_node_path9.default.join(dir, entry));
           }
         }
       }
     } else {
       for (const dir of current2) {
-        next.push(import_node_path10.default.join(dir, segment));
+        next.push(import_node_path9.default.join(dir, segment));
       }
     }
     current2 = next.filter(isDirectory);
@@ -15271,7 +14955,7 @@ function directoriesMatchingGlob(root, glob) {
   return current2;
 }
 function packageAt(dir) {
-  const packageJsonPath = import_node_path10.default.join(dir, "package.json");
+  const packageJsonPath = import_node_path9.default.join(dir, "package.json");
   const pkg = readJson(packageJsonPath);
   if (typeof pkg === "object" && pkg !== null && typeof pkg.name === "string") {
     return { name: pkg.name, packageJsonPath };
@@ -15279,7 +14963,7 @@ function packageAt(dir) {
   return null;
 }
 function workspacePackagesFrom(anchor) {
-  let dir = import_node_path10.default.resolve(anchor);
+  let dir = import_node_path9.default.resolve(anchor);
   for (; ; ) {
     const globs = workspaceGlobsAt(dir);
     if (globs !== null) {
@@ -15299,7 +14983,7 @@ function workspacePackagesFrom(anchor) {
         (a, b) => a.packageJsonPath.localeCompare(b.packageJsonPath)
       );
     }
-    const parent = import_node_path10.default.dirname(dir);
+    const parent = import_node_path9.default.dirname(dir);
     if (parent === dir) {
       return [];
     }
@@ -15333,7 +15017,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 projectFileStamp(paths);
+  return (0, import_extractor10.projectFileStamp)(paths);
 }
 function expandWorkspacePatterns(frameworks, anchor) {
   const marked = frameworks.some(
@@ -15841,11 +15525,11 @@ function extractConsumerBinding(unit, pattern, pack, resolution) {
     return null;
   }
   const method = extractBindingMethod(binding, callSite, pack, resolution);
-  const path15 = extractBindingPath(binding, callSite, pack, resolution);
-  return (0, import_behavioral_ir8.restBinding)({
+  const path14 = extractBindingPath(binding, callSite, pack, resolution);
+  return (0, import_behavioral_ir9.restBinding)({
     transport: pack.protocol,
     method: method ?? null,
-    path: path15 ?? null,
+    path: path14 ?? null,
     recognition: pack.name
   });
 }
@@ -15861,7 +15545,7 @@ function fileRouteBinding(filePath, unit, binding, pack) {
   if (method === void 0) {
     return null;
   }
-  return (0, import_behavioral_ir8.restBinding)({
+  return (0, import_behavioral_ir9.restBinding)({
     transport: pack.protocol,
     recognition: pack.name,
     method,
@@ -15991,7 +15675,7 @@ function computeSubUnitBarriers(unit, packs, ctx, tallies, file) {
       }
     } catch (err) {
       process.stderr.write(
-        recordPackFailure(tallies?.get(pack.name), {
+        (0, import_extractor3.recordPackFailure)(tallies?.get(pack.name), {
           pack: pack.name,
           hook: "subUnits",
           file,
@@ -16053,7 +15737,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         }
       } catch (err) {
         process.stderr.write(
-          recordPackFailure(tally, {
+          (0, import_extractor3.recordPackFailure)(tally, {
             pack: pack.name,
             hook: "discoverUnits",
             file: sourceFile.getFilePath(),
@@ -16114,7 +15798,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       stampWrappers(raw, unit, wrappers);
       const matchedPattern = unit.pattern ?? pack.discovery.find((d) => d.kind === unit.kind);
       if (unit.resolverInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlResolverBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir9.graphqlResolverBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           typeName: unit.resolverInfo.typeName,
@@ -16141,26 +15825,26 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
           }
         }
       } else if (unit.routeInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir9.restBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           method: unit.routeInfo.method,
           path: unit.routeInfo.path
         });
       } else if (unit.channelInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir8.messageBusBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir9.messageBusBinding)({
           recognition: pack.name,
           messageBus: unit.channelInfo.messageBus,
           channel: unit.channelInfo.channel
         });
       } else if (unit.invocationInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir8.unitInvocationBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir9.unitInvocationBinding)({
           recognition: pack.name,
           deploymentTarget: unit.invocationInfo.deploymentTarget,
           instanceName: unit.invocationInfo.instanceName
         });
       } else if (unit.operationInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlOperationBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir9.graphqlOperationBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           operationType: unit.operationInfo.operationType,
@@ -16249,14 +15933,14 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       }
       if (raw.boundaryBinding === null) {
         if (unit.packageExportInfo !== void 0) {
-          raw.boundaryBinding = (0, import_behavioral_ir8.packageExportBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir9.packageExportBinding)({
             transport: pack.protocol,
             recognition: pack.name,
             packageName: unit.packageExportInfo.packageName,
             exportPath: unit.packageExportInfo.exportPath
           });
         } else {
-          raw.boundaryBinding = (0, import_behavioral_ir8.functionCallBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir9.functionCallBinding)({
             transport: pack.protocol,
             recognition: pack.name,
             ...unit.functionCallInfo !== void 0 ? {
@@ -16266,9 +15950,9 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
           });
         }
       }
-      const summary = (0, import_extractor7.assembleSummary)(raw, options);
+      const summary = (0, import_extractor11.assembleSummary)(raw, options);
       if (unit.unfollowed !== void 0 && options?.gapHandling !== "silent") {
-        summary.gaps.push(unfollowedCallGap(unit.unfollowed));
+        summary.gaps.push((0, import_behavioral_ir3.unfollowedCallGap)(unit.unfollowed));
       }
       if (unit.metadata !== void 0 && Object.keys(unit.metadata).length > 0) {
         summary.metadata = {
@@ -16321,24 +16005,6 @@ function stampWrappers(raw, unit, wrappers) {
     recordFileDependency(wrapper.file);
   }
 }
-function stampModuleImports(summaries, project) {
-  const byFile2 = /* @__PURE__ */ new Map();
-  for (const summary of summaries) {
-    const file = summary.location.file;
-    let imports = byFile2.get(file);
-    if (imports === void 0) {
-      imports = internalImportsOf(project, file);
-      byFile2.set(file, imports);
-    }
-    if (imports.length === 0) {
-      continue;
-    }
-    summary.metadata = {
-      ...summary.metadata ?? {},
-      moduleImports: imports
-    };
-  }
-}
 function emitLibraryEnvReadMarkers(summaries, project, frameworks) {
   for (const pack of frameworks) {
     for (const declared of pack.libraryEnvVars ?? []) {
@@ -16366,14 +16032,14 @@ function fileImporting(project, modulePrefix) {
 function liftSchemasOntoDocuments(summaries) {
   const sdlByDocument = /* @__PURE__ */ new Map();
   for (const summary of summaries) {
-    const label = (0, import_behavioral_ir8.readSourceDocumentMetadata)(summary)?.label;
-    const graphql = (0, import_behavioral_ir8.readGraphqlMetadata)(summary);
+    const label = (0, import_behavioral_ir9.readSourceDocumentMetadata)(summary)?.label;
+    const graphql = (0, import_behavioral_ir9.readGraphqlMetadata)(summary);
     if (label === void 0 || graphql?.schemaSdl === void 0) {
       continue;
     }
     sdlByDocument.set(label, graphql.schemaSdl);
     const { schemaSdl: _movedToTheDocument, ...rest } = graphql;
-    summary.metadata = (0, import_behavioral_ir8.withGraphqlMetadata)(summary.metadata, rest);
+    summary.metadata = (0, import_behavioral_ir9.withGraphqlMetadata)(summary.metadata, rest);
   }
   for (const [label, schemaSdl] of sdlByDocument) {
     summaries.push(schemaDocumentSummary(label, schemaSdl));
@@ -16388,8 +16054,8 @@ function schemaDocumentSummary(label, schemaSdl) {
     transitions: [],
     gaps: [],
     confidence: { source: "declared", level: "high" },
-    metadata: (0, import_behavioral_ir8.withGraphqlMetadata)(
-      (0, import_behavioral_ir8.withSourceDocumentMetadata)(void 0, { label }),
+    metadata: (0, import_behavioral_ir9.withGraphqlMetadata)(
+      (0, import_behavioral_ir9.withSourceDocumentMetadata)(void 0, { label }),
       { schemaSdl }
     )
   };
@@ -16401,7 +16067,7 @@ function libraryEnvReadMarker(pack, declared, importer) {
     identity: {
       name: `${declared.module} env reads`,
       exportPath: null,
-      boundaryBinding: (0, import_behavioral_ir8.functionCallBinding)({
+      boundaryBinding: (0, import_behavioral_ir9.functionCallBinding)({
         transport: "in-process",
         recognition: pack.name
       })
@@ -16513,8 +16179,8 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
     if (pathArg === void 0) {
       continue;
     }
-    const path15 = pathFromArgument(pathArg, resolution);
-    if (path15 === void 0) {
+    const path14 = pathFromArgument(pathArg, resolution);
+    if (path14 === void 0) {
       continue;
     }
     const callerFunc = enclosingFunction(callExpr);
@@ -16526,7 +16192,7 @@ function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
       continue;
     }
     seen.add(dedupKey);
-    out.push(buildCallerSummary(wrapper, callerFunc, callExpr, path15, options));
+    out.push(buildCallerSummary(wrapper, callerFunc, callExpr, path14, options));
   }
   return out;
 }
@@ -16583,7 +16249,7 @@ function callerName(func) {
   }
   return "anonymous";
 }
-function buildCallerSummary(wrapper, callerFunc, callExpr, path15, options) {
+function buildCallerSummary(wrapper, callerFunc, callExpr, path14, options) {
   const wrapperBinding = wrapper.summary.identity.boundaryBinding;
   const wrapperRest = wrapperBinding?.semantics.name === "rest" ? wrapperBinding.semantics : null;
   const syntheticPack = {
@@ -16612,13 +16278,13 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path15, options) {
     }
   };
   const raw = extractCodeStructure(unit, syntheticPack);
-  raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir9.restBinding)({
     transport: wrapperBinding?.transport ?? "http",
     method: wrapperRest?.method ?? null,
-    path: path15,
+    path: path14,
     recognition: wrapperBinding?.recognition ?? "unknown"
   });
-  const summary = (0, import_extractor7.assembleSummary)(raw, options);
+  const summary = (0, import_extractor11.assembleSummary)(raw, options);
   summary.metadata = {
     ...summary.metadata ?? {},
     derivedFromWrapper: {
@@ -16637,25 +16303,12 @@ function named(summaries, workspace, runRoot) {
   });
   return summaries;
 }
-var saidWhyNoCache = false;
 function extractionConfigStamp(config) {
   return [
     `includeReachable=${config.includeReachable !== false}`,
     `gapHandling=${config.extractorOptions?.gapHandling ?? "default"}`
   ].join(",");
 }
-function declineWhenRunFromSource(cacheDir) {
-  if (cacheDir === null || adapterCodeStamp().kind === "bundle") {
-    return cacheDir;
-  }
-  if (!saidWhyNoCache) {
-    saidWhyNoCache = true;
-    process.stderr.write(
-      "[suss] extraction cache off: this process loaded the adapter from source, where nothing can tell one build of it from another. Run the built adapter to cache.\n"
-    );
-  }
-  return null;
-}
 function loadRunFiles(project, candidatePaths, timer) {
   if (candidatePaths !== null) {
     const deep2 = timer.time(
@@ -16686,7 +16339,7 @@ function createTypeScriptAdapter(suppliedConfig) {
     ...suppliedConfig,
     frameworks: expandWorkspacePatterns(
       suppliedConfig.frameworks,
-      suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? import_node_path11.default.dirname(suppliedConfig.tsConfigFilePath) : void 0)
+      suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? import_node_path10.default.dirname(suppliedConfig.tsConfigFilePath) : void 0)
     )
   };
   const project = config.project ?? new import_ts_morph66.Project(
@@ -16695,24 +16348,18 @@ function createTypeScriptAdapter(suppliedConfig) {
       skipAddingFilesFromTsConfig: true
     } : { skipAddingFilesFromTsConfig: true }
   );
-  const runRoot = config.projectRoot ?? (config.tsConfigFilePath !== void 0 ? workspaceRootFor(import_node_path11.default.dirname(config.tsConfigFilePath)) : void 0);
+  const runRoot = config.projectRoot ?? (config.tsConfigFilePath !== void 0 ? workspaceRootFor(import_node_path10.default.dirname(config.tsConfigFilePath)) : void 0);
   let lazyBootstrapped = false;
   let projectFileSet;
   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)
+    config.cacheDir === null ? null : config.cacheDir ?? (config.tsConfigFilePath !== void 0 ? import_node_path10.default.join(import_node_path10.default.dirname(config.tsConfigFilePath), ".suss", "cache") : null)
   );
-  const cache = createCacheLayer(cacheDir);
+  const cache = (0, import_extractor11.createCacheLayer)(cacheDir);
   const packsDigest = `${computeAdapterPacksDigest(
     config.frameworks.map(
       (p) => p.version !== void 0 ? { name: p.name, version: p.version } : { name: p.name }
     )
   )}|${extractionConfigStamp(config)}|ws:${workspaceExpansionStamp(config.frameworks)}`;
-  const digestFor = (files) => {
-    const inputs = config.frameworks.flatMap(
-      (pack) => pack.discoveryInputs?.(files) ?? []
-    );
-    return `${packsDigest}|reads:${projectFileStamp(inputs)}`;
-  };
   const packWrappers = config.frameworks.flatMap(
     (pack) => pack.transparentWrappers ?? []
   );
@@ -16745,8 +16392,8 @@ function createTypeScriptAdapter(suppliedConfig) {
       return named(summaries, config.workspace, runRoot);
     },
     async extractAll() {
-      const timer = createTimer();
-      const tallies = createPackTallies(config.frameworks);
+      const timer = (0, import_extractor8.createTimer)();
+      const tallies = (0, import_extractor3.createPackTallies)(config.frameworks);
       forgetUnreadableExportFiles();
       forgetReassignedNamesUnstated();
       const lazyEligible = !lazyBootstrapped && config.tsConfigFilePath !== void 0 && config.project === void 0;
@@ -16756,20 +16403,17 @@ function createTypeScriptAdapter(suppliedConfig) {
           config.tsConfigFilePath ?? raise("lazy bootstrap requires tsConfigFilePath")
         )
       ) : null;
-      const adapterPacksDigest = cacheDir === null ? packsDigest : timer.time(
-        "cache.digest",
-        () => digestFor(
-          tsconfigFileList ?? project.getSourceFiles().map((sf) => sf.getFilePath())
-        )
-      );
-      const cacheInput = tsconfigFileList !== null ? {
-        files: tsconfigFileList,
-        adapterPacksDigest,
-        tsconfigPath: config.tsConfigFilePath ?? raise("lazy bootstrap requires tsConfigFilePath")
-      } : {
-        project,
+      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);
+      });
+      const cacheInput = {
+        // Empty when cacheDir is null: a no-op cache layer never reads
+        // the file list, so there is nothing worth resolving early.
+        files: cacheFiles ?? [],
         adapterPacksDigest,
-        ...config.tsConfigFilePath !== void 0 ? { tsconfigPath: config.tsConfigFilePath } : {}
+        ...config.tsConfigFilePath !== void 0 ? { configPath: config.tsConfigFilePath } : {}
       };
       const lookup = await timer.timeAsync(
         "cache.lookup",
@@ -16975,7 +16619,8 @@ function createTypeScriptAdapter(suppliedConfig) {
             ],
             access: collectAccessRecognizers(config.frameworks, tallies),
             resolveWrittenValue: (value) => resolution.resolveWrittenValue(value),
-            resolveCallableSources: (value, alsoFrom) => resolution.resolveCallableSources(value, alsoFrom)
+            resolveCallableSources: (value, alsoFrom) => resolution.resolveCallableSources(value, alsoFrom),
+            sourceDeclarationsBehind: (declaration) => sourceDeclarationsBehind(declaration, resolution)
           },
           // Reached units the cache already serves emit nothing,
           // the way a cold run's seeds do not.
@@ -17012,7 +16657,10 @@ function createTypeScriptAdapter(suppliedConfig) {
       }
       timer.time(
         "stampModuleImports",
-        () => stampModuleImports(enriched, project)
+        () => (0, import_extractor11.stampModuleImports)(enriched, (file) => {
+          const imports = internalImportsOf(project, file);
+          return imports.length === 0 ? void 0 : imports;
+        })
       );
       timer.time(
         "emitLibraryEnvReadMarkers",
@@ -17071,7 +16719,7 @@ function createTypeScriptAdapter(suppliedConfig) {
       });
       const composed = timer.time(
         "composeWrappers",
-        () => (0, import_extractor7.composeWrappers)(enriched)
+        () => (0, import_extractor11.composeWrappers)(enriched)
       );
       if (config.onTiming !== void 0) {
         config.onTiming(timer.report());
@@ -17103,7 +16751,7 @@ function createTypeScriptAdapter(suppliedConfig) {
   };
 }
 function mountAssumptionsAgree(record2, index) {
-  return Object.entries(record2.mountPrefixes).every(
+  return Object.entries(record2.meta.mountPrefixes).every(
     ([childId, prefix]) => (index.prefixForId?.(childId) ?? "") === prefix
   );
 }
@@ -17203,10 +16851,10 @@ function mergeWithReused(reused, fresh, ownersBySummary) {
   return { summaries: [...reusedKept, ...fresh], reusedKept, reusedOwners };
 }
 function readsRunLevelJoins(summary) {
-  if ((0, import_behavioral_ir8.readSourceDocumentMetadata)(summary) !== void 0) {
+  if ((0, import_behavioral_ir9.readSourceDocumentMetadata)(summary) !== void 0) {
     return true;
   }
-  if ((0, import_behavioral_ir8.readGraphqlMetadata)(summary)?.client !== void 0) {
+  if ((0, import_behavioral_ir9.readGraphqlMetadata)(summary)?.client !== void 0) {
     return true;
   }
   const semantics = summary.identity.boundaryBinding?.semantics;
@@ -17263,7 +16911,7 @@ function buildCacheAttribution(args) {
       cacheable,
       deps: [...deps].sort(),
       claims: sink.claims,
-      mountPrefixes: Object.fromEntries(sink.mountPrefixes),
+      meta: { mountPrefixes: Object.fromEntries(sink.mountPrefixes) },
       packs: packNamesByPath.get(rootPath) ?? []
     });
   }
@@ -17396,7 +17044,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
   if (parent.identity.boundaryBinding !== null) {
     raw.boundaryBinding = parent.identity.boundaryBinding;
   }
-  const summary = (0, import_extractor7.assembleSummary)(raw, options);
+  const summary = (0, import_extractor11.assembleSummary)(raw, options);
   if (subUnit.metadata !== void 0 && Object.keys(subUnit.metadata).length > 0) {
     summary.metadata = {
       ...summary.metadata ?? {},
@@ -17408,8 +17056,8 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 }
 
 // src/bootstrap/noTsconfigProject.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var import_ts_morph67 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -17440,7 +17088,7 @@ function findSourceFiles(rootDir, depth = 0) {
   const found = [];
   let entries;
   try {
-    entries = import_node_fs7.default.readdirSync(rootDir, { withFileTypes: true });
+    entries = import_node_fs4.default.readdirSync(rootDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -17448,10 +17096,10 @@ function findSourceFiles(rootDir, depth = 0) {
     if (entry.name.startsWith(".") || SKIP_DIRECTORIES.has(entry.name)) {
       continue;
     }
-    const full = import_node_path12.default.join(rootDir, entry.name);
+    const full = import_node_path11.default.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       found.push(...findSourceFiles(full, depth + 1));
-    } else if (SOURCE_EXTENSIONS.has(import_node_path12.default.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
+    } else if (SOURCE_EXTENSIONS.has(import_node_path11.default.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
       found.push(full);
     }
   }
@@ -17486,15 +17134,15 @@ function createProjectWithoutTsconfig(rootDir) {
   return { project, files };
 }
 function findNearestTsconfig(startDir) {
-  let dir = import_node_path12.default.resolve(startDir);
+  let dir = import_node_path11.default.resolve(startDir);
   while (true) {
     for (const name of ["tsconfig.json", "jsconfig.json"]) {
-      const candidate = import_node_path12.default.join(dir, name);
-      if (import_node_fs7.default.existsSync(candidate)) {
+      const candidate = import_node_path11.default.join(dir, name);
+      if (import_node_fs4.default.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = import_node_path12.default.dirname(dir);
+    const parent = import_node_path11.default.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -17503,7 +17151,7 @@ function findNearestTsconfig(startDir) {
 }
 
 // src/facts/why.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var import_ts_morph68 = require("ts-morph");
 var import_resolution7 = require("@suss/resolution");
 var JS_PHRASES = {
@@ -17511,12 +17159,12 @@ var JS_PHRASES = {
     reason: `${describe(tuple[0])} is a .bind of ${describe(tuple[1])}, which runs the same function`
   })
 };
-var WhySession = class {
+var TypeScriptWhySession = class {
   project;
   store;
   root;
   constructor(options) {
-    this.root = import_node_path13.default.resolve(options.dir);
+    this.root = import_node_path12.default.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
     this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph68.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
@@ -17605,7 +17253,7 @@ var WhySession = class {
     };
   }
   sourceFileAt(file) {
-    const absolute = import_node_path13.default.resolve(this.root, file);
+    const absolute = import_node_path12.default.resolve(this.root, file);
     const loaded = this.project.getSourceFile(absolute);
     if (loaded !== void 0) {
       return loaded;
@@ -17619,7 +17267,7 @@ var WhySession = class {
   /** A module key: a file path said relative to the root, or a package name. */
   displayPath(key) {
     if (key.startsWith(this.root)) {
-      return import_node_path13.default.relative(this.root, key);
+      return import_node_path12.default.relative(this.root, key);
     }
     return key;
   }
@@ -17647,228 +17295,8 @@ function displayNameOf(node) {
   return text.length > 40 ? `${text.slice(0, 40)}...` : text;
 }
 
-// src/packHealth.ts
-function stagesOf(funnel) {
-  const stages = [];
-  const gateSaysSomething = funnel.gates.length > 0 && funnel.unresolvedGates.length === 0;
-  if (funnel.recognizes && !funnel.discovers && gateSaysSomething) {
-    stages.push({
-      from: { count: funnel.unitsInGatedFiles, name: "unit bodies" },
-      to: { count: funnel.effectsRecognized, name: "effects" }
-    });
-  }
-  if (funnel.discovers && gateSaysSomething) {
-    stages.push({
-      from: { count: funnel.candidateFiles, name: "source files" },
-      to: { count: funnel.unitsDiscovered, name: "units" }
-    });
-  }
-  stages.push(
-    {
-      from: { count: funnel.unitsClaimed, name: "units" },
-      to: { count: funnel.summariesBound, name: "summaries" }
-    },
-    {
-      from: { count: funnel.summariesBound, name: "summaries" },
-      to: { count: funnel.summariesWithBehavior, name: "transitions" }
-    }
-  );
-  return stages;
-}
-function funnelDrops(packs) {
-  const violations = [];
-  for (const funnel of packs) {
-    for (const stage of stagesOf(funnel)) {
-      if (stage.from.count === 0 || stage.to.count > 0) {
-        continue;
-      }
-      violations.push({
-        label: funnel.pack,
-        detail: `${stage.from.count} ${stage.from.name} -> 0 ${stage.to.name}`
-      });
-    }
-  }
-  return violations;
-}
-function recognizersWithNoUnits(packs) {
-  return packs.filter(
-    (funnel) => funnel.recognizes && !funnel.discovers && funnel.gates.length > 0 && funnel.unresolvedGates.length === 0 && funnel.candidateFiles > 0 && funnel.unitsInGatedFiles === 0 && // The closure walks a recognizer-only pack's gated exports as
-    // roots, so effects recognized there mean the run worked and
-    // the missing framework pack costs attribution, not existence.
-    funnel.effectsRecognized === 0
-  ).map((funnel) => ({
-    label: funnel.pack,
-    detail: `${funnel.candidateFiles} gated files, and no pack in this run discovered a unit in them. ${funnel.pack} reads calls inside units another pack finds, so add the pack that finds this project's handlers (-f express, -f fastify, ...), or run suss init to work out which.`
-  }));
-}
-function helpersThatMatchedNothing(packs) {
-  return packs.flatMap(
-    (funnel) => funnel.helpersUnmatched.map((helper) => ({
-      label: funnel.pack,
-      detail: `${helper} matched no call in this run, so whatever it registers is missing. suss read that helper out of the project and then failed to match a call to it, which is a bug in suss rather than in your code.`
-    }))
-  );
-}
-function unversionedPacks(packs) {
-  return packs.filter((funnel) => funnel.version === null).map((funnel) => ({
-    label: funnel.pack,
-    detail: "no version declared"
-  }));
-}
-function selfCollisions(packs) {
-  return packs.filter((funnel) => funnel.selfCollisions > 0).map((funnel) => ({
-    label: funnel.pack,
-    detail: `${funnel.selfCollisions} ${funnel.selfCollisions === 1 ? "unit" : "units"} matched twice, second dropped`
-  }));
-}
-function threwWhileReading(packs) {
-  return packs.filter((funnel) => funnel.failures.length > 0).map((funnel) => {
-    const first = funnel.failures[0];
-    const rest = funnel.failures.length - 1;
-    const alsoIn = rest > 0 ? ` (+${rest} more)` : "";
-    return {
-      label: funnel.pack,
-      detail: `${first.hook} on ${first.file}${alsoIn}: ${first.message}`
-    };
-  });
-}
-function packGradients(report) {
-  const gradients = [];
-  for (const funnel of report.packs) {
-    if (funnel.declarations === null) {
-      continue;
-    }
-    gradients.push(gradientOf(funnel.pack, funnel.declarations.declarations));
-  }
-  return gradients;
-}
-function gradientOf(pack, declarations) {
-  const gradient = {
-    pack,
-    dataLinks: 0,
-    functionLinks: [],
-    astLinks: [],
-    withoutExample: []
-  };
-  for (const declaration of declarations) {
-    gradient.dataLinks += declaration.dataLinks;
-    for (const question of declaration.functionLinks) {
-      gradient.functionLinks.push(`${declaration.name}.${question}`);
-    }
-    for (const question of declaration.astLinks) {
-      gradient.astLinks.push(`${declaration.name}.${question}`);
-    }
-    if (declaration.example === null) {
-      gradient.withoutExample.push(declaration.name);
-    }
-  }
-  return gradient;
-}
-function opaqueLinks(gradients) {
-  return gradients.filter((gradient) => gradient.functionLinks.length > 0).map((gradient) => ({
-    label: gradient.pack,
-    detail: `${gradient.functionLinks.join(", ")} (${gradient.dataLinks} data)`
-  }));
-}
-function reachesTheSyntaxTree(gradients) {
-  return gradients.filter((gradient) => gradient.astLinks.length > 0).map((gradient) => ({
-    label: gradient.pack,
-    detail: gradient.astLinks.join(", ")
-  }));
-}
-function undocumentedDeclarations(gradients) {
-  return gradients.filter((gradient) => gradient.withoutExample.length > 0).map((gradient) => ({
-    label: gradient.pack,
-    detail: gradient.withoutExample.join(", ")
-  }));
-}
-function evaluatePackHealth(report) {
-  const gradients = packGradients(report);
-  return [
-    {
-      name: "no pack throws while it reads",
-      code: "threw",
-      audience: "run",
-      violations: threwWhileReading(report.packs)
-    },
-    {
-      name: "no pack finds something and records nothing",
-      code: "no-output",
-      audience: "run",
-      violations: funnelDrops(report.packs)
-    },
-    {
-      name: "no pack collides with itself",
-      code: "double-match",
-      audience: "run",
-      violations: selfCollisions(report.packs)
-    },
-    {
-      name: "every recognizer had units to look inside",
-      code: "no-units",
-      audience: "run",
-      violations: recognizersWithNoUnits(report.packs)
-    },
-    {
-      name: "every registration helper the run read matched a call",
-      code: "no-helper",
-      audience: "run",
-      violations: helpersThatMatchedNothing(report.packs)
-    },
-    {
-      name: "every pack declares a version",
-      code: "no-version",
-      audience: "pack",
-      violations: unversionedPacks(report.packs)
-    },
-    {
-      name: "every link a declared pack states is data",
-      code: "fn-link",
-      audience: "pack",
-      violations: opaqueLinks(gradients)
-    },
-    {
-      name: "no declared pack reads the syntax tree",
-      code: "ast-link",
-      audience: "pack",
-      violations: reachesTheSyntaxTree(gradients)
-    },
-    {
-      name: "every declaration states an example",
-      code: "no-example",
-      audience: "pack",
-      violations: undocumentedDeclarations(gradients)
-    }
-  ];
-}
-function formatPackHealth(checks, audiences) {
-  const fired = checks.filter(
-    (check) => check.violations.length > 0 && audiences.includes(check.audience)
-  );
-  if (fired.length === 0) {
-    return "";
-  }
-  const rows = fired.flatMap(
-    (check) => check.violations.map((violation) => ({
-      code: check.code,
-      pack: violation.label,
-      detail: violation.detail
-    }))
-  );
-  const codeWidth = Math.max(...rows.map((row) => row.code.length));
-  const packWidth = Math.max(...rows.map((row) => row.pack.length));
-  const lines = ["", `Pack health (${rows.length}):`];
-  for (const row of rows) {
-    lines.push(
-      `  ${row.code.padEnd(codeWidth)}  ${row.pack.padEnd(packWidth)}  ${row.detail}`
-    );
-  }
-  return `${lines.join("\n")}
-`;
-}
-
 // src/stubEvidence.ts
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_ts_morph69 = require("ts-morph");
 function stubEvidenceIn(project, packageName, root) {
   const resolution = new ResolutionStore();
@@ -17884,7 +17312,7 @@ function stubEvidenceIn(project, packageName, root) {
         calls: []
       };
       entry.calls.push({
-        file: import_node_path14.default.relative(root, sourceFile.getFilePath()).split(import_node_path14.default.sep).join("/"),
+        file: import_node_path13.default.relative(root, sourceFile.getFilePath()).split(import_node_path13.default.sep).join("/"),
         line: one.call.getStartLineNumber(),
         args: one.call.getArguments().map((arg) => effectArgOf(arg))
       });
@@ -17899,7 +17327,7 @@ function stubEvidence(options) {
   const project = new import_ts_morph69.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());
+  const root = options.tsConfigFilePath !== void 0 ? import_node_path13.default.dirname(options.tsConfigFilePath) : import_node_path13.default.resolve(options.directory ?? process.cwd());
   if (options.tsConfigFilePath === void 0) {
     project.addSourceFilesAtPaths([
       `${root}/**/*.{ts,tsx,js,jsx}`,
@@ -17912,7 +17340,7 @@ function stubEvidence(options) {
 0 && (module.exports = {
   ADAPTER_VERSION,
   ResolutionStore,
-  WhySession,
+  TypeScriptWhySession,
   accessContextFor,
   buildProjectHelperIndex,
   callOpsFor,
@@ -17925,13 +17353,11 @@ function stubEvidence(options) {
   createTsSubUnitContext,
   createTypeScriptAdapter,
   discoverUnits,
-  evaluatePackHealth,
   exportedDeclarationsOf,
   extractCodeStructure,
   extractRawBranches,
   findNearestTsconfig,
   findTerminals,
-  formatPackHealth,
   functionTargetOf,
   importDeclarationsOf,
   importedNamesOf,