@suss/adapter-typescript 0.21.0 → 0.22.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/adapter.ts
-import path11 from "path";
+import path10 from "path";
 import {
   Node as Node64,
   Project,
@@ -21,7 +21,10 @@ import {
 import { Database as Database5 } from "@suss/datalog";
 import {
   assembleSummary as assembleSummary3,
-  composeWrappers
+  composeWrappers,
+  createCacheLayer,
+  runDigest,
+  stampModuleImports
 } from "@suss/extractor";
 
 // src/assembly.ts
@@ -40,6 +43,7 @@ import { Node as Node5, SyntaxKind as SyntaxKind2 } from "ts-morph";
 import { Node as Node2, SyntaxKind } from "ts-morph";
 
 // src/walk/nodeKeys.ts
+import { declarationKey } from "@suss/behavioral-ir";
 function offsetKeyOf(node) {
   return offsetKeyFor(node.getSourceFile().getFilePath(), {
     start: node.getStart(),
@@ -47,7 +51,7 @@ function offsetKeyOf(node) {
   });
 }
 function offsetKeyFor(file, span) {
-  return `${file}:${span.start}-${span.end}`;
+  return declarationKey(file, span);
 }
 function lineRangeKey(file, startLine, endLine) {
   return `${file}:${startLine}-${endLine}`;
@@ -1867,8 +1871,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);
     }
@@ -1915,6 +1919,20 @@ function importedFilePathsOf(project, filePath) {
   cache.set(filePath, paths);
   return paths;
 }
+function resolutionCacheFor(project, options) {
+  const existing = resolutionCachesByProject.get(project);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const fresh = ts.createModuleResolutionCache(
+    project.getFileSystem().getCurrentDirectory(),
+    (name) => name,
+    options
+  );
+  resolutionCachesByProject.set(project, fresh);
+  return fresh;
+}
+var resolutionCachesByProject = /* @__PURE__ */ new WeakMap();
 function specifierCacheFor(project) {
   const existing = specifiersByProject.get(project);
   if (existing !== void 0) {
@@ -1941,13 +1959,15 @@ function readSpecifierPaths(project, filePath, options, host) {
     return [];
   }
   const scanned = ts.preProcessFile(text, true, true);
+  const cache = resolutionCacheFor(project, options);
   const paths = [];
   for (const imported of scanned.importedFiles) {
     const resolved = ts.resolveModuleName(
       imported.fileName,
       filePath,
       options,
-      host
+      host,
+      cache
     ).resolvedModule?.resolvedFileName;
     if (resolved !== void 0 && !resolved.includes("/node_modules/")) {
       paths.push(resolved);
@@ -2204,11 +2224,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;
     }
@@ -2225,7 +2245,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);
@@ -2542,6 +2562,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() === SyntaxKind3.NullKeyword || Node13.isIdentifier(value) && value.getText() === "undefined";
+}
+function isConstruction(value) {
+  return Node13.isCallExpression(value) || Node13.isNewExpression(value);
+}
+function sourceOf(node) {
+  return node.getText().replace(/\s+/g, " ").trim();
+}
 function writesToField(declaration) {
   const remembered = byField.get(declaration);
   if (remembered !== void 0) {
@@ -2632,6 +2678,9 @@ function assignmentsInFile(sourceFile) {
 function isAssignmentOperator(kind) {
   return kind >= SyntaxKind3.FirstAssignment && kind <= SyntaxKind3.LastAssignment;
 }
+function writesItsWholeValue(kind) {
+  return kind === SyntaxKind3.EqualsToken || kind === SyntaxKind3.QuestionQuestionEqualsToken || kind === SyntaxKind3.BarBarEqualsToken;
+}
 function writeAt(node) {
   if (Node13.isBinaryExpression(node)) {
     const operator = node.getOperatorToken().getKind();
@@ -2639,7 +2688,7 @@ function writeAt(node) {
     if (!isAssignmentOperator(operator) || !(Node13.isIdentifier(target) || Node13.isPropertyAccessExpression(target))) {
       return null;
     }
-    const value = operator === SyntaxKind3.EqualsToken ? node.getRight() : null;
+    const value = writesItsWholeValue(operator) ? node.getRight() : null;
     return { target, write: { value, node } };
   }
   if (Node13.isPrefixUnaryExpression(node) || Node13.isPostfixUnaryExpression(node)) {
@@ -3030,11 +3079,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;
   }
-  fact(db, "endsHolding", declarationId, emitValue(db, table, last));
+  const construction = sameConstructionAcrossWrites(values);
+  if (construction !== null) {
+    fact(db, "endsHolding", declarationId, emitValue(db, table, construction));
+    return;
+  }
+  reassignedUnstated.add(declarationId);
 }
 var reassignedUnstated = /* @__PURE__ */ new Set();
 function reassignedNamesUnstated() {
@@ -3046,23 +3100,31 @@ function forgetReassignedNamesUnstated() {
 function emitFieldValues(db, table, declaration) {
   const { values, inOrder } = writesToField(declaration);
   const last = values[values.length - 1];
-  if (!inOrder || last === void 0 || !Node14.isExpression(last)) {
+  if (inOrder && last !== void 0 && Node14.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 && Node14.isExpression(last)) {
+    fact(db, "binds", referenceId, emitValue(db, table, last));
     return;
   }
-  if (!Node14.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);
@@ -3526,7 +3588,8 @@ var JS_RULES = [
 ];
 var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
   rules: [...SHARED_RULES, ...JS_RULES, ...RESOLUTION_QUESTIONS],
-  demandDriven: []
+  demandDriven: [],
+  demands: []
 } : deriveOnDemand(
   [...SHARED_RULES, ...JS_RULES, ...RESOLUTION_QUESTIONS],
   ANSWER_RELATIONS
@@ -3553,7 +3616,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 Database2();
   table = createNodeTable();
@@ -3569,7 +3634,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();
@@ -3600,19 +3665,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);
@@ -3649,11 +3714,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
@@ -3669,17 +3730,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`
@@ -3699,18 +3760,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 && Node15.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
@@ -3724,10 +3796,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();
@@ -3743,6 +3813,7 @@ var ResolutionStore = class {
     if (candidates.size > 1) {
       return {
         construction: null,
+        candidate: null,
         candidates: [...candidates].filter(
           (one) => this.constructionComesFrom(valueId, one, importModule, importName)
         ).length
@@ -3750,7 +3821,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(
@@ -3759,6 +3830,7 @@ var ResolutionStore = class {
         importModule,
         importName
       ) ? single : null,
+      candidate: single,
       candidates: 1
     };
   }
@@ -3818,11 +3890,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]
@@ -3841,8 +3913,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.
    */
@@ -3870,49 +3942,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
         });
@@ -3971,67 +4006,89 @@ var ResolutionStore = class {
     const refined = new Set(
       [...byPath.values()].filter((one) => one.path.length > 1).map((one) => tupleKey(one.path.slice(0, -1)))
     );
-    const origins = [...byPath.values()].filter((one) => !refined.has(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(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
@@ -4050,6 +4107,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.
@@ -4099,24 +4177,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) {
@@ -4132,15 +4204,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))) {
@@ -4149,12 +4220,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.
    */
@@ -4174,33 +4245,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 exports = /* @__PURE__ */ new Map();
     for (const tuple of this.db.lookup("wantedModuleExport", 0, filePath)) {
       const node = this.table.byId.get(String(tuple[2]));
@@ -4217,22 +4265,9 @@ var ResolutionStore = class {
     }
     return exports;
   }
-  /** 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();
@@ -4246,7 +4281,7 @@ var ResolutionStore = class {
         candidates.add(resolved);
       }
     }
-    return candidates.size === 0 ? null : [...candidates];
+    return [...candidates];
   }
   derive() {
     if (!this.stale) {
@@ -4305,18 +4340,6 @@ function pairHalves(pair) {
   const [module = "", name = ""] = tupleKeyParts(pair);
   return { module, name };
 }
-function namesAPackage(moduleKey) {
-  return !moduleKey.startsWith("/") || moduleKey.includes("/node_modules/");
-}
-function neverWritable(value) {
-  if (!Node15.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)],
@@ -4337,35 +4360,12 @@ import path3 from "path";
 // src/diagnostics.ts
 import path2 from "path";
 import { ts as ts3 } from "ts-morph";
-import { BOUNDARY_ROLE } from "@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;
-}
+import {
+  createPackTallies,
+  emptyTally,
+  recordPackFailure,
+  summaryCountsByPack
+} from "@suss/extractor";
 function commonDirectoryOf(files) {
   const absolute = files.filter((f) => path2.isAbsolute(f));
   const first = absolute[0];
@@ -4442,30 +4442,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 (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) {
@@ -4490,7 +4466,11 @@ function buildExtractionReport(args) {
   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 counted = bySummary.get(pack.name) ?? {
+      bound: 0,
+      providers: 0,
+      withBehavior: 0
+    };
     return {
       pack: pack.name,
       version: pack.version ?? null,
@@ -4719,13 +4699,26 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (Node16.isCallExpression(written) || Node16.isNewExpression(written)) {
+  if (Node16.isNewExpression(written)) {
     return written;
   }
+  if (Node16.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 && Node16.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);
@@ -4787,7 +4780,7 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
       }
     } else if (Node17.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (Node17.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText()) || resolvesToKnownInstance(subject, match, resolution))) {
+      if (Node17.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;
@@ -6397,14 +6390,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
     };
@@ -6603,7 +6596,6 @@ function labelOfExpression(node) {
 }
 
 // src/discovery/packageExports.ts
-import fs4 from "fs";
 import { Node as Node29 } from "ts-morph";
 
 // src/packageExports.ts
@@ -6632,7 +6624,8 @@ function resolvePackageExports(packageJsonPath, opts = {}) {
       packageName,
       subPath,
       exportPathPrefix: subPathToPrefix(subPath),
-      sourceFile: src
+      sourceFile: src,
+      publishedFile: path5.resolve(pkgDir, distPath)
     });
   };
   const exportsField = pkg.exports;
@@ -6652,6 +6645,53 @@ function resolvePackageExports(packageJsonPath, opts = {}) {
   }
   return { packageName, entries, warnings };
 }
+var packageExportsCache = /* @__PURE__ */ new Map();
+var PATH_STAMP_SEPARATOR = "";
+function packageJsonStamp(packageJsonPath) {
+  try {
+    const stat = fs3.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 = path5.resolve(start);
+  for (let up = 0; up < 12; up += 1) {
+    if (packageNameAt(at) !== null) {
+      return at;
+    }
+    const parent = path5.dirname(at);
+    if (parent === at) {
+      break;
+    }
+    at = parent;
+  }
+  return null;
+}
+function packageNameAt(dir) {
+  try {
+    const manifest = JSON.parse(
+      fs3.readFileSync(path5.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) {
@@ -6701,8 +6741,55 @@ function resolveSourceFor(pkgDir, distPath, srcRoot) {
   return null;
 }
 
+// src/resolve/sourceDeclaration.ts
+import path6 from "path";
+function sourceDeclarationsBehind(decl, resolution, visited = /* @__PURE__ */ new Set()) {
+  const file = decl.getSourceFile();
+  if (!file.isDeclarationFile() || file.isInNodeModules()) {
+    return [decl];
+  }
+  const packageDir = namedPackageDirAbove(path6.dirname(file.getFilePath()));
+  if (packageDir === null || visited.has(packageDir)) {
+    return [decl];
+  }
+  visited.add(packageDir);
+  const project = file.getProject();
+  const { entries } = resolvePackageExportsCached(
+    path6.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
 import { Node as Node28, SyntaxKind as SyntaxKind6 } from "ts-morph";
+var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl) {
   if (Node28.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
@@ -6742,16 +6829,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 (Node28.isArrowFunction(fn)) {
     const body2 = fn.getBody();
     if (Node28.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) => {
@@ -6768,9 +6859,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 (Node28.isObjectLiteralExpression(expr)) {
     collectFromObjectLiteral(expr, out, seen);
+    return;
   }
-  return out;
+  if (depth >= MAX_BUILDER_HOPS || !Node28.isCallExpression(expr)) {
+    return;
+  }
+  const callee = expr.getExpression();
+  if (!Node28.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 (Node28.isFunctionDeclaration(decl)) {
+      return decl;
+    }
+    if (Node28.isVariableDeclaration(decl)) {
+      const init = decl.getInitializer();
+      if (init !== void 0 && (Node28.isArrowFunction(init) || Node28.isFunctionExpression(init))) {
+        return init;
+      }
+    }
+  }
+  return null;
 }
 function collectFromObjectLiteral(node, out, seen) {
   const e = peelParens(node);
@@ -6805,31 +6940,31 @@ function collectFromObjectLiteral(node, out, seen) {
         out.push({ func: v3, name });
       }
     }
+    if (Node28.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 = fs4.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 [];
@@ -6864,7 +6999,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 (Node29.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
           if (init !== void 0 && (Node29.isArrowFunction(init) || Node29.isFunctionExpression(init))) {
@@ -7019,7 +7157,7 @@ function attributedCalls(sourceFile, packages, resolution) {
       return null;
     }
     if (!methodComesFromSource(callee)) {
-      return subject;
+      return null;
     }
     return {
       packageName: subject.packageName,
@@ -7133,12 +7271,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 {
@@ -7162,8 +7300,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();
@@ -7171,7 +7309,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++) {
@@ -7181,18 +7319,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 (Node31.isStringLiteral(node)) {
@@ -7262,12 +7400,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 (!Node32.isCallExpression(node)) {
       return;
@@ -7461,8 +7599,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 (Node32.isVariableDeclaration(node)) {
+      const init = node.getInitializer();
+      if (init !== void 0 && Node32.isCallExpression(init)) {
+        setToCalls.add(node.getName());
+      }
+      return;
+    }
+    if (!Node32.isCallExpression(node)) {
+      return;
+    }
+    const callee = node.getExpression();
+    if (!Node32.isPropertyAccessExpression(callee) || !Node32.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(
@@ -7527,9 +7711,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 ((Node32.isCallExpression(node) || Node32.isNewExpression(node)) && node.getExpression().getText() === importedLocalName && !Node32.isVariableDeclaration(node.getParent())) {
+      constructions.push(node);
+    }
+  });
+  return constructions;
+}
 function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolution) {
   const subjects = registrationSubjectsOf(
     sourceFile,
@@ -7537,7 +7745,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 = [];
@@ -7618,11 +7826,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;
@@ -7639,8 +7847,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
@@ -7772,7 +7980,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 (Node33.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
@@ -7790,16 +7998,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 (Node33.isStringLiteral(node) || Node33.isNoSubstitutionTemplateLiteral(node)) {
@@ -7812,7 +8020,7 @@ function handlerName(value) {
 }
 
 // src/discovery/registrationTemplate.ts
-import path6 from "path";
+import path7 from "path";
 import { Node as Node35 } from "ts-morph";
 import { joinMountedPath as joinMountedPath2 } from "@suss/resolution";
 
@@ -7821,6 +8029,10 @@ import {
   Node as Node34,
   SyntaxKind as SyntaxKind7
 } from "ts-morph";
+import {
+  unfollowedCallGap,
+  worthRecording
+} from "@suss/behavioral-ir";
 function isInExternalCode(sourceFile) {
   if (sourceFile.isDeclarationFile()) {
     return true;
@@ -7874,6 +8086,19 @@ function declarationsBehind(symbol) {
 function isParameterOf(declaration, scanning) {
   return Node34.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";
@@ -7894,36 +8119,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) {
@@ -7933,8 +8128,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);
@@ -7948,7 +8143,7 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution, moun
         ...subject === void 0 ? {} : { registrationSubjectId: nodeId(subject) },
         routeInfo: {
           method: reg.method.toUpperCase(),
-          path: prefix === "" ? path15 : joinMountedPath2(prefix, path15)
+          path: prefix === "" ? path14 : joinMountedPath2(prefix, path14)
         }
       });
     }
@@ -7981,7 +8176,7 @@ function subjectOfCall(sourceFile, args, match, resolution) {
 }
 function helperCallsOf(sourceFile, match, resolution) {
   const module = match.importModule;
-  if (module !== void 0 && !path6.isAbsolute(module)) {
+  if (module !== void 0 && !path7.isAbsolute(module)) {
     const store = resolution ?? new ResolutionStore();
     return callsResolvingTo(sourceFile, store, {
       module,
@@ -8427,24 +8622,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 && Node38.isPropertyAccessExpression(parent) && parent.getExpression() === current2) {
-      path15.push(parent.getName());
+      path14.push(parent.getName());
       current2 = parent;
       continue;
     }
     if (parent !== void 0 && Node38.isElementAccessExpression(parent) && parent.getExpression() === current2) {
       const argument = parent.getArgumentExpression();
       if (argument !== void 0 && Node38.isStringLiteral(argument)) {
-        path15.push(argument.getLiteralValue());
+        path14.push(argument.getLiteralValue());
         current2 = parent;
         continue;
       }
     }
-    return path15;
+    return path14;
   }
 }
 function declaresParameterOf(node, func) {
@@ -9143,142 +9338,40 @@ function importSpecifierMatches(decl, expectedModule) {
   return Node41.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) || Node41.isDecorator(node)) {
       traversal.skip();
       return;
     }
-    if (Node41.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 (Node41.isSpreadElement(node)) {
-      const parent = node.getParent();
-      if (parent !== void 0 && (Node41.isArrayLiteralExpression(parent) || Node41.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 (Node41.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 (Node41.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 (Node41.isArrowFunction(node)) {
-      const body = node.getBody();
-      const { call, async } = Node41.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 (Node41.isCallExpression(node)) {
-      const parent = node.getParent();
-      if (parent === void 0) {
-        return;
-      }
-      const isArrayElement = Node41.isArrayLiteralExpression(parent);
-      const isPropertyValue = Node41.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 && Node41.isParenthesizedExpression(current2)) {
+    current2 = current2.getParent();
+  }
+  return current2 !== void 0 && Node41.isAwaitExpression(current2);
 }
 function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   if (recognizers.length === 0) {
@@ -9621,22 +9714,6 @@ function enclosingStatementLine(node) {
   }
   return startLineOf(node);
 }
-function unwrapCall(node) {
-  if (Node41.isAwaitExpression(node)) {
-    const inner = node.getExpression();
-    if (Node41.isCallExpression(inner)) {
-      return { call: inner, async: true };
-    }
-    return { call: null, async: false };
-  }
-  if (Node41.isParenthesizedExpression(node)) {
-    return unwrapCall(node.getExpression());
-  }
-  if (Node41.isCallExpression(node)) {
-    return { call: node, async: false };
-  }
-  return { call: null, async: false };
-}
 
 // src/terminals/index.ts
 import { Node as Node51 } from "ts-morph";
@@ -11678,6 +11755,22 @@ function firesOn(site, branch) {
   }
   return site.alwaysRuns || 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 (Node52.isPropertyAccessExpression(parent) || Node52.isElementAccessExpression(parent) || Node52.isCallExpression(parent)) && parent.getExpression() === node;
+}
 var isDefaultConditionList = (conditions) => conditions.length === 0 || conditions.every(
   (c) => c.source === "earlyReturn" || c.source === "earlyThrow"
 );
@@ -11816,11 +11909,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(
@@ -11866,9 +11956,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) {
@@ -11913,397 +12003,47 @@ function indexFunctions(sf) {
   return index;
 }
 
-// src/cache.ts
-import { createHash as createHash2 } from "crypto";
-import fs5 from "fs/promises";
-import path7 from "path";
-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(path7.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(path7.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(path7.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 fs5.mkdir(entryDir, { recursive: true });
-      await fs5.writeFile(
-        path7.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
+import { Node as Node54 } from "ts-morph";
+import { restBinding } from "@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 (!Node54.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 fs5.readFile(filePath);
-    return createHash2("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 fs5.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 = createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  return path7.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 fs5.utimes(entryDir, now, now);
-  } catch {
+  if (Node54.isPropertyAssignment(parent)) {
+    return parent;
   }
-}
-async function evictOldEntries(cacheDir, keepDir) {
-  try {
-    await fs5.rm(path7.join(cacheDir, "manifest.json"), { force: true });
-    const entries = await fs5.readdir(cacheDir, { withFileTypes: true });
-    const dirs = await Promise.all(
-      entries.filter((e) => e.isDirectory() && isEntryDir(e.name)).map(async (e) => {
-        const dir = path7.join(cacheDir, e.name);
-        const stat = await fs5.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) => fs5.rm(d.dir, { recursive: true, force: true }))
-    );
-  } catch {
+  if (Node54.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 fs5.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 || !Node54.isObjectLiteralExpression(handlersObj)) {
     return null;
   }
-  try {
-    const stat = await fs5.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 fs5.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
-import { Node as Node54 } from "ts-morph";
-import { restBinding } from "@suss/behavioral-ir";
-function extractDeclaredBody(node) {
-  if (node === void 0) {
-    return null;
-  }
-  if (!Node54.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 (Node54.isPropertyAssignment(parent)) {
-    return parent;
-  }
-  if (Node54.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 || !Node54.isObjectLiteralExpression(handlersObj)) {
-    return null;
-  }
-  const routerCall = handlersObj.getParent();
-  if (routerCall === void 0 || !Node54.isCallExpression(routerCall)) {
+  const routerCall = handlersObj.getParent();
+  if (routerCall === void 0 || !Node54.isCallExpression(routerCall)) {
     return null;
   }
   const args = routerCall.getArguments();
@@ -12405,7 +12145,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   }
   const responses = [];
   let method;
-  let path15;
+  let path14;
   for (const prop of endpointNode.getProperties()) {
     if (!Node54.isPropertyAssignment(prop)) {
       continue;
@@ -12420,7 +12160,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
       if (val !== void 0 && Node54.isStringLiteral(val)) {
-        path15 = val.getLiteralValue();
+        path14 = val.getLiteralValue();
       }
     }
     if (propName === pattern.responseExtraction.property) {
@@ -12444,10 +12184,10 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   if (responses.length === 0) {
     return null;
   }
-  const boundaryBinding = method !== void 0 || path15 !== void 0 ? restBinding({
+  const boundaryBinding = method !== void 0 || path14 !== void 0 ? restBinding({
     transport: "http",
     method: method ?? null,
-    path: path15 ?? null,
+    path: path14 ?? null,
     recognition: framework
   }) : null;
   return {
@@ -13086,8 +12826,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);
       }
     }
@@ -13681,7 +13421,7 @@ function scalarOrRef(node) {
 }
 
 // src/moduleInit.ts
-import { assembleSummary } from "@suss/extractor";
+import { assembleSummary, moduleInitStructure } from "@suss/extractor";
 function moduleInitName(sourceFile) {
   return sourceFile.getBaseName();
 }
@@ -13689,44 +13429,15 @@ function moduleInitSummary(sourceFile, effects, options) {
   if (effects.length === 0) {
     return null;
   }
-  const end = sourceFile.getEnd();
-  const raw = {
-    identity: {
+  return assembleSummary(
+    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 assembleSummary(raw, options);
+      range: { start: 0, end: sourceFile.getEnd() },
+      effects
+    }),
+    options
+  );
 }
 
 // src/referencedFiles.ts
@@ -13874,7 +13585,7 @@ function deriveBoundaryEffects(summaries, facts) {
 
 // src/resolve/reachableClosure.ts
 import { Node as Node60 } from "ts-morph";
-import { functionCallBinding } from "@suss/behavioral-ir";
+import { functionCallBinding, TargetPlacements } from "@suss/behavioral-ir";
 import { Database as Database3, evaluate as evaluate4, lit as lit4, rule as rule4, variable as variable2 } from "@suss/datalog";
 import { assembleSummary as assembleSummary2 } from "@suss/extractor";
 var reachablePack = {
@@ -13898,6 +13609,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 (!Node60.isCallExpression(call)) {
     return null;
@@ -13922,19 +13639,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 (!Node60.isJsxOpeningElement(node) && !Node60.isJsxSelfClosingElement(node)) {
     return null;
   }
@@ -13954,7 +13694,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)
     }
   };
 }
@@ -13962,7 +13703,11 @@ function collectReachable(func, scan) {
   const inFunc = { ...scan, scanning: func };
   const candidates = [];
   const stops = [];
+  const placements = new 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}`;
@@ -13979,8 +13724,28 @@ function collectReachable(func, scan) {
     seen.add(key);
     candidates.push(outcome.candidate);
   };
+  const recordPassedArgs = (call, calleeText, calleeOutcome) => {
+    if (!Node60.isCallExpression(call)) {
+      return;
+    }
+    const calleeTarget = declaredAtOf(calleeOutcome);
+    call.getArguments().forEach((arg, position) => {
+      if (!Node60.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;
@@ -13994,8 +13759,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();
@@ -14070,6 +13851,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) {
@@ -14114,9 +13899,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)
@@ -14124,6 +13917,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)) {
@@ -14163,6 +13964,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) {
@@ -14194,6 +14004,90 @@ function recordStops(stopsByKey, summariesByKey, options) {
     }
   }
 }
+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 }) => unfollowedCallGap({ callee, reason: "unboundParameter" })
+        )
+      );
+    }
+  }
+}
 
 // src/resolve/rethrowEnrichment.ts
 import { Node as Node61 } from "ts-morph";
@@ -14929,10 +14823,10 @@ function readArrayLiteralText(node) {
 }
 
 // src/summaryIdentity.ts
-import fs6 from "fs";
 import path8 from "path";
 import {
   disambiguateSummaryIds,
+  linkCallsToSummaries,
   summaryIdFromParts
 } from "@suss/behavioral-ir";
 function workspaceRootFor(anchor) {
@@ -14949,32 +14843,6 @@ function workspaceNameFor(root) {
   const folder = path8.basename(path8.resolve(root));
   return folder.length > 0 ? folder : null;
 }
-function namedPackageDirAbove(start) {
-  let at = path8.resolve(start);
-  for (let up = 0; up < 12; up += 1) {
-    if (packageNameAt(at) !== null) {
-      return at;
-    }
-    const parent = path8.dirname(at);
-    if (parent === at) {
-      break;
-    }
-    at = parent;
-  }
-  return null;
-}
-function packageNameAt(dir) {
-  try {
-    const manifest = JSON.parse(
-      fs6.readFileSync(path8.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,7 +14852,7 @@ function nameSummaries(summaries, args) {
     summary.identity.id = idFor(args.workspace, file, summary);
   }
   disambiguateSummaryIds(summaries);
-  nameWhatEachCallReaches(summaries);
+  linkCallsToSummaries(summaries);
 }
 function relativeFile(file, projectRoot) {
   if (projectRoot === void 0 || !path8.isAbsolute(file)) {
@@ -15001,185 +14869,35 @@ function idFor(workspace, file, summary) {
     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 };
-    }
-  };
-}
+import { createTimer, noopTimer } from "@suss/extractor";
 
 // src/version.ts
-import { createHash as createHash3 } from "crypto";
-import fs7 from "fs";
-import { createRequire } from "module";
-import path9 from "path";
-import { fileURLToPath } from "url";
+import { createAdapterStamp } from "@suss/extractor";
+import {
+  computeContentHash,
+  computeDistHashFrom,
+  projectFileStamp
+} from "@suss/extractor";
 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 = fileURLToPath(import.meta.url);
-    const hash = computeDistHashFrom(path9.dirname(selfPath));
-    return hash.length > 0 ? { kind: "bundle", hash } : SOURCE_STAMP;
-  } catch {
-    return SOURCE_STAMP;
-  }
-}
-function computeDistHashFrom(dir) {
-  const candidates = [path9.join(dir, "index.js"), path9.join(dir, "index.cjs")];
-  for (const candidate of candidates) {
-    if (!fs7.existsSync(candidate)) {
-      continue;
-    }
-    return computeContentHash([candidate, ...analysisBundles()]);
-  }
-  return "";
-}
-function computeContentHash(paths) {
-  if (paths.length === 0) {
-    return "";
-  }
-  const hash = createHash3("sha256");
-  for (const file of paths) {
-    try {
-      hash.update(fs7.readFileSync(file));
-    } catch {
-      return "";
-    }
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-function projectFileStamp(paths) {
-  if (paths.length === 0) {
-    return "none";
-  }
-  const hash = createHash3("sha256");
-  for (const file of [...paths].sort()) {
-    hash.update(file);
-    hash.update("\0");
-    try {
-      hash.update(fs7.readFileSync(file));
-    } catch {
-      hash.update("absent");
-    }
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-function analysisBundles() {
-  const require2 = createRequire(import.meta.url);
-  const found = [];
-  for (const name of ANALYSIS_PACKAGES) {
-    try {
-      found.push(require2.resolve(name));
-    } catch {
-    }
-  }
-  return found;
-}
+var stamp = 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
-import fs8 from "fs";
-import path10 from "path";
+import fs4 from "fs";
+import path9 from "path";
 function readJson(filePath) {
   try {
-    return JSON.parse(fs8.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs4.readFileSync(filePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -15206,7 +14924,7 @@ function pnpmWorkspaceGlobs(yamlText) {
   return globs;
 }
 function workspaceGlobsAt(dir) {
-  const pkg = readJson(path10.join(dir, "package.json"));
+  const pkg = readJson(path9.join(dir, "package.json"));
   if (typeof pkg === "object" && pkg !== null && "workspaces" in pkg) {
     const ws = pkg.workspaces;
     if (Array.isArray(ws)) {
@@ -15218,10 +14936,10 @@ function workspaceGlobsAt(dir) {
       );
     }
   }
-  const pnpmPath = path10.join(dir, "pnpm-workspace.yaml");
-  if (fs8.existsSync(pnpmPath)) {
+  const pnpmPath = path9.join(dir, "pnpm-workspace.yaml");
+  if (fs4.existsSync(pnpmPath)) {
     try {
-      return pnpmWorkspaceGlobs(fs8.readFileSync(pnpmPath, "utf8"));
+      return pnpmWorkspaceGlobs(fs4.readFileSync(pnpmPath, "utf8"));
     } catch {
       return null;
     }
@@ -15230,14 +14948,14 @@ function workspaceGlobsAt(dir) {
 }
 function isDirectory(candidate) {
   try {
-    return fs8.statSync(candidate).isDirectory();
+    return fs4.statSync(candidate).isDirectory();
   } catch {
     return false;
   }
 }
 function subdirectoriesOf(dir) {
   try {
-    return fs8.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
+    return fs4.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
   } catch {
     return [];
   }
@@ -15255,13 +14973,13 @@ function directoriesMatchingGlob(root, glob) {
       for (const dir of current2) {
         for (const entry of subdirectoriesOf(dir)) {
           if (pattern.test(entry)) {
-            next.push(path10.join(dir, entry));
+            next.push(path9.join(dir, entry));
           }
         }
       }
     } else {
       for (const dir of current2) {
-        next.push(path10.join(dir, segment));
+        next.push(path9.join(dir, segment));
       }
     }
     current2 = next.filter(isDirectory);
@@ -15269,7 +14987,7 @@ function directoriesMatchingGlob(root, glob) {
   return current2;
 }
 function packageAt(dir) {
-  const packageJsonPath = path10.join(dir, "package.json");
+  const packageJsonPath = path9.join(dir, "package.json");
   const pkg = readJson(packageJsonPath);
   if (typeof pkg === "object" && pkg !== null && typeof pkg.name === "string") {
     return { name: pkg.name, packageJsonPath };
@@ -15277,7 +14995,7 @@ function packageAt(dir) {
   return null;
 }
 function workspacePackagesFrom(anchor) {
-  let dir = path10.resolve(anchor);
+  let dir = path9.resolve(anchor);
   for (; ; ) {
     const globs = workspaceGlobsAt(dir);
     if (globs !== null) {
@@ -15297,7 +15015,7 @@ function workspacePackagesFrom(anchor) {
         (a, b) => a.packageJsonPath.localeCompare(b.packageJsonPath)
       );
     }
-    const parent = path10.dirname(dir);
+    const parent = path9.dirname(dir);
     if (parent === dir) {
       return [];
     }
@@ -15839,11 +15557,11 @@ function extractConsumerBinding(unit, pattern, pack, resolution) {
     return null;
   }
   const method = extractBindingMethod(binding, callSite, pack, resolution);
-  const path15 = extractBindingPath(binding, callSite, pack, resolution);
+  const path14 = extractBindingPath(binding, callSite, pack, resolution);
   return restBinding2({
     transport: pack.protocol,
     method: method ?? null,
-    path: path15 ?? null,
+    path: path14 ?? null,
     recognition: pack.name
   });
 }
@@ -16319,24 +16037,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 ?? []) {
@@ -16511,8 +16211,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);
@@ -16524,7 +16224,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;
 }
@@ -16581,7 +16281,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 = {
@@ -16613,7 +16313,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path15, options) {
   raw.boundaryBinding = restBinding2({
     transport: wrapperBinding?.transport ?? "http",
     method: wrapperRest?.method ?? null,
-    path: path15,
+    path: path14,
     recognition: wrapperBinding?.recognition ?? "unknown"
   });
   const summary = assembleSummary3(raw, options);
@@ -16635,25 +16335,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(
@@ -16684,7 +16371,7 @@ function createTypeScriptAdapter(suppliedConfig) {
     ...suppliedConfig,
     frameworks: expandWorkspacePatterns(
       suppliedConfig.frameworks,
-      suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? path11.dirname(suppliedConfig.tsConfigFilePath) : void 0)
+      suppliedConfig.projectRoot ?? (suppliedConfig.tsConfigFilePath !== void 0 ? path10.dirname(suppliedConfig.tsConfigFilePath) : void 0)
     )
   };
   const project = config.project ?? new Project(
@@ -16693,11 +16380,11 @@ function createTypeScriptAdapter(suppliedConfig) {
       skipAddingFilesFromTsConfig: true
     } : { skipAddingFilesFromTsConfig: true }
   );
-  const runRoot = config.projectRoot ?? (config.tsConfigFilePath !== void 0 ? workspaceRootFor(path11.dirname(config.tsConfigFilePath)) : void 0);
+  const runRoot = config.projectRoot ?? (config.tsConfigFilePath !== void 0 ? workspaceRootFor(path10.dirname(config.tsConfigFilePath)) : void 0);
   let lazyBootstrapped = false;
   let projectFileSet;
   const cacheDir = declineWhenRunFromSource(
-    config.cacheDir === null ? null : config.cacheDir ?? (config.tsConfigFilePath !== void 0 ? path11.join(path11.dirname(config.tsConfigFilePath), ".suss", "cache") : null)
+    config.cacheDir === null ? null : config.cacheDir ?? (config.tsConfigFilePath !== void 0 ? path10.join(path10.dirname(config.tsConfigFilePath), ".suss", "cache") : null)
   );
   const cache = createCacheLayer(cacheDir);
   const packsDigest = `${computeAdapterPacksDigest(
@@ -16705,12 +16392,6 @@ function createTypeScriptAdapter(suppliedConfig) {
       (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 ?? []
   );
@@ -16754,20 +16435,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 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",
@@ -16973,7 +16651,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.
@@ -17010,7 +16689,10 @@ function createTypeScriptAdapter(suppliedConfig) {
       }
       timer.time(
         "stampModuleImports",
-        () => stampModuleImports(enriched, project)
+        () => stampModuleImports(enriched, (file) => {
+          const imports = internalImportsOf(project, file);
+          return imports.length === 0 ? void 0 : imports;
+        })
       );
       timer.time(
         "emitLibraryEnvReadMarkers",
@@ -17101,7 +16783,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
   );
 }
@@ -17261,7 +16943,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) ?? []
     });
   }
@@ -17406,8 +17088,8 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 }
 
 // src/bootstrap/noTsconfigProject.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs5 from "fs";
+import path11 from "path";
 import {
   ModuleKind,
   ModuleResolutionKind,
@@ -17443,7 +17125,7 @@ function findSourceFiles(rootDir, depth = 0) {
   const found = [];
   let entries;
   try {
-    entries = fs9.readdirSync(rootDir, { withFileTypes: true });
+    entries = fs5.readdirSync(rootDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -17451,10 +17133,10 @@ function findSourceFiles(rootDir, depth = 0) {
     if (entry.name.startsWith(".") || SKIP_DIRECTORIES.has(entry.name)) {
       continue;
     }
-    const full = path12.join(rootDir, entry.name);
+    const full = path11.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       found.push(...findSourceFiles(full, depth + 1));
-    } else if (SOURCE_EXTENSIONS.has(path12.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
+    } else if (SOURCE_EXTENSIONS.has(path11.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
       found.push(full);
     }
   }
@@ -17489,15 +17171,15 @@ function createProjectWithoutTsconfig(rootDir) {
   return { project, files };
 }
 function findNearestTsconfig(startDir) {
-  let dir = path12.resolve(startDir);
+  let dir = path11.resolve(startDir);
   while (true) {
     for (const name of ["tsconfig.json", "jsconfig.json"]) {
-      const candidate = path12.join(dir, name);
-      if (fs9.existsSync(candidate)) {
+      const candidate = path11.join(dir, name);
+      if (fs5.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = path12.dirname(dir);
+    const parent = path11.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -17506,7 +17188,7 @@ function findNearestTsconfig(startDir) {
 }
 
 // src/facts/why.ts
-import path13 from "path";
+import path12 from "path";
 import { Node as Node65, Project as Project3, SyntaxKind as SyntaxKind12 } from "ts-morph";
 import { explainResolutionProof, renderExplanation } from "@suss/resolution";
 var JS_PHRASES = {
@@ -17514,12 +17196,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 = path13.resolve(options.dir);
+    this.root = path12.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
     this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new Project3({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
@@ -17608,7 +17290,7 @@ var WhySession = class {
     };
   }
   sourceFileAt(file) {
-    const absolute = path13.resolve(this.root, file);
+    const absolute = path12.resolve(this.root, file);
     const loaded = this.project.getSourceFile(absolute);
     if (loaded !== void 0) {
       return loaded;
@@ -17622,7 +17304,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 path13.relative(this.root, key);
+      return path12.relative(this.root, key);
     }
     return key;
   }
@@ -17650,228 +17332,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
-import path14 from "path";
+import path13 from "path";
 import { Project as Project4 } from "ts-morph";
 function stubEvidenceIn(project, packageName, root) {
   const resolution = new ResolutionStore();
@@ -17887,7 +17349,7 @@ function stubEvidenceIn(project, packageName, root) {
         calls: []
       };
       entry.calls.push({
-        file: path14.relative(root, sourceFile.getFilePath()).split(path14.sep).join("/"),
+        file: path13.relative(root, sourceFile.getFilePath()).split(path13.sep).join("/"),
         line: one.call.getStartLineNumber(),
         args: one.call.getArguments().map((arg) => effectArgOf(arg))
       });
@@ -17902,7 +17364,7 @@ function stubEvidence(options) {
   const project = new Project4(
     options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : { compilerOptions: { allowJs: true } }
   );
-  const root = options.tsConfigFilePath !== void 0 ? path14.dirname(options.tsConfigFilePath) : path14.resolve(options.directory ?? process.cwd());
+  const root = options.tsConfigFilePath !== void 0 ? path13.dirname(options.tsConfigFilePath) : path13.resolve(options.directory ?? process.cwd());
   if (options.tsConfigFilePath === void 0) {
     project.addSourceFilesAtPaths([
       `${root}/**/*.{ts,tsx,js,jsx}`,
@@ -17914,7 +17376,7 @@ function stubEvidence(options) {
 export {
   ADAPTER_VERSION,
   ResolutionStore,
-  WhySession,
+  TypeScriptWhySession,
   accessContextFor,
   buildProjectHelperIndex,
   callOpsFor,
@@ -17927,13 +17389,11 @@ export {
   createTsSubUnitContext,
   createTypeScriptAdapter,
   discoverUnits,
-  evaluatePackHealth,
   exportedDeclarationsOf,
   extractCodeStructure,
   extractRawBranches,
   findNearestTsconfig,
   findTerminals,
-  formatPackHealth,
   functionTargetOf,
   importDeclarationsOf,
   importedNamesOf,