@suss/adapter-typescript 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   ADAPTER_VERSION: () => ADAPTER_VERSION,
   ResolutionStore: () => ResolutionStore,
+  WhySession: () => WhySession,
   collectAncestorBranches: () => collectAncestorBranches,
   collectClientFieldAccesses: () => collectClientFieldAccesses,
   computeAdapterPacksDigest: () => computeAdapterPacksDigest,
@@ -57,7 +58,8 @@ __export(index_exports, {
   readName: () => readName,
   resolveAliasedSymbol: () => resolveAliasedSymbol,
   resolveSubject: () => resolveSubject,
-  rootIdentifier: () => rootIdentifier
+  rootIdentifier: () => rootIdentifier2,
+  workspaceRootFor: () => workspaceRootFor
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1076,24 +1078,64 @@ function collectFallthroughCaseLabels(caseClause) {
 }
 
 // src/paths/pathConditions.ts
-var import_ts_morph8 = require("ts-morph");
+var import_ts_morph9 = require("ts-morph");
 var import_extractor2 = require("@suss/extractor");
 
-// src/paths/lowering.ts
+// src/walk/descent.ts
 var import_ts_morph7 = require("ts-morph");
+var NO_BARRIERS = /* @__PURE__ */ new Set();
+function isDescentStop(node, func, barriers = NO_BARRIERS) {
+  if (node === func) {
+    return false;
+  }
+  if (import_ts_morph7.Node.isFunctionDeclaration(node) || import_ts_morph7.Node.isMethodDeclaration(node)) {
+    return true;
+  }
+  if (import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isFunctionExpression(node)) {
+    return barriers.has(node);
+  }
+  return false;
+}
+function isInlineCallback(node, func, barriers = NO_BARRIERS) {
+  if (node === func) {
+    return false;
+  }
+  if (!(import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isFunctionExpression(node))) {
+    return false;
+  }
+  return !barriers.has(node);
+}
+function isModuleScopeStop(node) {
+  return import_ts_morph7.Node.isFunctionDeclaration(node) || import_ts_morph7.Node.isMethodDeclaration(node) || import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isFunctionExpression(node) || import_ts_morph7.Node.isClassDeclaration(node) || import_ts_morph7.Node.isClassExpression(node);
+}
+function crossesNestedFunctionScope(node, func) {
+  let current2 = node;
+  while (current2 !== void 0 && current2 !== func) {
+    if (startsItsOwnScope(current2)) {
+      return true;
+    }
+    current2 = current2.getParent();
+  }
+  return false;
+}
+function startsItsOwnScope(node) {
+  return import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isFunctionExpression(node) || import_ts_morph7.Node.isFunctionDeclaration(node) || import_ts_morph7.Node.isMethodDeclaration(node) || import_ts_morph7.Node.isGetAccessorDeclaration(node) || import_ts_morph7.Node.isSetAccessorDeclaration(node) || import_ts_morph7.Node.isConstructorDeclaration(node);
+}
+
+// src/paths/lowering.ts
+var import_ts_morph8 = require("ts-morph");
 var import_extractor = require("@suss/extractor");
-var isFunctionBoundary = (node) => import_ts_morph7.Node.isFunctionDeclaration(node) || import_ts_morph7.Node.isFunctionExpression(node) || import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isMethodDeclaration(node);
 function exitKindOf(stmt) {
   let sawReturn = false;
   let sawThrow = false;
   const visit = (node) => {
-    if (node !== stmt && isFunctionBoundary(node)) {
+    if (node !== stmt && startsItsOwnScope(node)) {
       return;
     }
-    if (import_ts_morph7.Node.isReturnStatement(node)) {
+    if (import_ts_morph8.Node.isReturnStatement(node)) {
       sawReturn = true;
     }
-    if (import_ts_morph7.Node.isThrowStatement(node)) {
+    if (import_ts_morph8.Node.isThrowStatement(node)) {
       sawThrow = true;
     }
     for (const child of node.getChildren()) {
@@ -1110,14 +1152,14 @@ var statementsOf = (stmt) => {
   if (stmt === void 0) {
     return [];
   }
-  if (import_ts_morph7.Node.isBlock(stmt)) {
+  if (import_ts_morph8.Node.isBlock(stmt)) {
     return stmt.getStatements();
   }
   return [stmt];
 };
-var isLoop = (stmt) => import_ts_morph7.Node.isForOfStatement(stmt) || import_ts_morph7.Node.isForInStatement(stmt) || import_ts_morph7.Node.isForStatement(stmt) || import_ts_morph7.Node.isWhileStatement(stmt) || import_ts_morph7.Node.isDoStatement(stmt);
+var isLoop = (stmt) => import_ts_morph8.Node.isForOfStatement(stmt) || import_ts_morph8.Node.isForInStatement(stmt) || import_ts_morph8.Node.isForStatement(stmt) || import_ts_morph8.Node.isWhileStatement(stmt) || import_ts_morph8.Node.isDoStatement(stmt);
 function getLoopBody(stmt) {
-  if (import_ts_morph7.Node.isForOfStatement(stmt) || import_ts_morph7.Node.isForInStatement(stmt) || import_ts_morph7.Node.isForStatement(stmt) || import_ts_morph7.Node.isWhileStatement(stmt) || import_ts_morph7.Node.isDoStatement(stmt)) {
+  if (import_ts_morph8.Node.isForOfStatement(stmt) || import_ts_morph8.Node.isForInStatement(stmt) || import_ts_morph8.Node.isForStatement(stmt) || import_ts_morph8.Node.isWhileStatement(stmt) || import_ts_morph8.Node.isDoStatement(stmt)) {
     return stmt.getStatement();
   }
   return void 0;
@@ -1132,37 +1174,97 @@ var conditionOf = (expr) => ({
   sourceText: expr.getText(),
   expression: expr
 });
-function lowerStatement(stmt, rawToStructured) {
-  const structured = buildStructured(stmt, rawToStructured);
-  rawToStructured.set(stmt, structured);
+function lowerStatement(stmt, ctx) {
+  const structured = {
+    ...buildStructured(stmt, ctx),
+    callbacks: lowerCallbacksIn(ownExpressionsOf(stmt), ctx)
+  };
+  ctx.rawToStructured.set(stmt, structured);
   return structured;
 }
-function lowerList(stmts, rawToStructured) {
-  return spliceBlocks(stmts).map((s) => lowerStatement(s, rawToStructured));
+function lowerList(stmts, ctx) {
+  return spliceBlocks(stmts).map((s) => lowerStatement(s, ctx));
+}
+function ownExpressionsOf(stmt) {
+  if (import_ts_morph8.Node.isIfStatement(stmt) || import_ts_morph8.Node.isSwitchStatement(stmt)) {
+    return [stmt.getExpression()];
+  }
+  if (import_ts_morph8.Node.isWhileStatement(stmt) || import_ts_morph8.Node.isDoStatement(stmt)) {
+    return [stmt.getExpression()];
+  }
+  if (import_ts_morph8.Node.isForOfStatement(stmt) || import_ts_morph8.Node.isForInStatement(stmt)) {
+    return [stmt.getInitializer(), stmt.getExpression()];
+  }
+  if (import_ts_morph8.Node.isForStatement(stmt)) {
+    return [
+      stmt.getInitializer(),
+      stmt.getCondition(),
+      stmt.getIncrementor()
+    ].filter((n) => n !== void 0);
+  }
+  if (import_ts_morph8.Node.isTryStatement(stmt)) {
+    return [];
+  }
+  if (import_ts_morph8.Node.isReturnStatement(stmt) || import_ts_morph8.Node.isThrowStatement(stmt)) {
+    const value = stmt.getExpression();
+    return value === void 0 ? [] : [value];
+  }
+  if (import_ts_morph8.Node.isBreakStatement(stmt) || import_ts_morph8.Node.isContinueStatement(stmt)) {
+    return [];
+  }
+  return [stmt];
+}
+function lowerCallbacksIn(parts, ctx) {
+  const bodies = [];
+  const visit = (node, root) => {
+    if (node !== root && isDescentStop(node, ctx.func, ctx.barriers)) {
+      return;
+    }
+    if (node !== root && (import_ts_morph8.Node.isArrowFunction(node) || import_ts_morph8.Node.isFunctionExpression(node)) && isInlineCallback(node, ctx.func, ctx.barriers)) {
+      const body = node.getBody();
+      if (body !== void 0 && import_ts_morph8.Node.isBlock(body)) {
+        bodies.push(lowerList(body.getStatements(), ctx));
+        return;
+      }
+    } else if (node !== root && startsItsOwnScope(node)) {
+      return;
+    }
+    for (const child of node.getChildren()) {
+      visit(child, root);
+    }
+  };
+  for (const part of parts) {
+    visit(part, part);
+  }
+  return bodies;
+}
+function lowerExpressionBodyCallbacks(expression, func, barriers = NO_BARRIERS) {
+  return lowerCallbacksIn([expression], {
+    func,
+    barriers,
+    rawToStructured: /* @__PURE__ */ new Map()
+  });
 }
 function spliceBlocks(stmts) {
   return stmts.flatMap(
-    (s) => import_ts_morph7.Node.isBlock(s) ? spliceBlocks(s.getStatements()) : [s]
+    (s) => import_ts_morph8.Node.isBlock(s) ? spliceBlocks(s.getStatements()) : [s]
   );
 }
-function buildStructured(stmt, rawToStructured) {
-  if (import_ts_morph7.Node.isIfStatement(stmt)) {
+function buildStructured(stmt, ctx) {
+  if (import_ts_morph8.Node.isIfStatement(stmt)) {
     const elseBranch = stmt.getElseStatement();
     return {
       kind: "if",
       condition: conditionOf(stmt.getExpression()),
-      thenBody: lowerList(
-        statementsOf(stmt.getThenStatement()),
-        rawToStructured
-      ),
-      elseBody: elseBranch === void 0 ? null : lowerList(statementsOf(elseBranch), rawToStructured),
+      thenBody: lowerList(statementsOf(stmt.getThenStatement()), ctx),
+      elseBody: elseBranch === void 0 ? null : lowerList(statementsOf(elseBranch), ctx),
       exitKind: exitKindOf(stmt)
     };
   }
-  if (import_ts_morph7.Node.isSwitchStatement(stmt)) {
+  if (import_ts_morph8.Node.isSwitchStatement(stmt)) {
     return {
       kind: "switch",
-      groups: lowerSwitchGroups(stmt, rawToStructured),
+      groups: lowerSwitchGroups(stmt, ctx),
       exitKind: exitKindOf(stmt)
     };
   }
@@ -1170,36 +1272,36 @@ function buildStructured(stmt, rawToStructured) {
     return {
       kind: "loop",
       condition: { sourceText: loopHeaderText(stmt), expression: null },
-      body: lowerList(statementsOf(getLoopBody(stmt)), rawToStructured),
+      body: lowerList(statementsOf(getLoopBody(stmt)), ctx),
       exitKind: exitKindOf(stmt)
     };
   }
-  if (import_ts_morph7.Node.isTryStatement(stmt)) {
+  if (import_ts_morph8.Node.isTryStatement(stmt)) {
     const catchClause = stmt.getCatchClause();
     const finallyBlock = stmt.getFinallyBlock();
     return {
       kind: "try",
-      tryBody: lowerList(stmt.getTryBlock().getStatements(), rawToStructured),
-      catchBody: catchClause === void 0 ? null : lowerList(catchClause.getBlock().getStatements(), rawToStructured),
-      finallyBody: finallyBlock === void 0 ? null : lowerList(finallyBlock.getStatements(), rawToStructured),
+      tryBody: lowerList(stmt.getTryBlock().getStatements(), ctx),
+      catchBody: catchClause === void 0 ? null : lowerList(catchClause.getBlock().getStatements(), ctx),
+      finallyBody: finallyBlock === void 0 ? null : lowerList(finallyBlock.getStatements(), ctx),
       exitKind: exitKindOf(stmt)
     };
   }
-  if (import_ts_morph7.Node.isReturnStatement(stmt)) {
+  if (import_ts_morph8.Node.isReturnStatement(stmt)) {
     return { kind: "exit", exit: "return", exitKind: exitKindOf(stmt) };
   }
-  if (import_ts_morph7.Node.isThrowStatement(stmt)) {
+  if (import_ts_morph8.Node.isThrowStatement(stmt)) {
     return { kind: "exit", exit: "throw", exitKind: exitKindOf(stmt) };
   }
-  if (import_ts_morph7.Node.isBreakStatement(stmt)) {
+  if (import_ts_morph8.Node.isBreakStatement(stmt)) {
     return { kind: "exit", exit: "break", exitKind: exitKindOf(stmt) };
   }
-  if (import_ts_morph7.Node.isContinueStatement(stmt)) {
+  if (import_ts_morph8.Node.isContinueStatement(stmt)) {
     return { kind: "exit", exit: "continue", exitKind: exitKindOf(stmt) };
   }
   return { kind: "opaque", exitKind: exitKindOf(stmt) };
 }
-function lowerSwitchGroups(stmt, rawToStructured) {
+function lowerSwitchGroups(stmt, ctx) {
   const switchText = stmt.getExpression().getText();
   const groups = [];
   let pendingLabels = [];
@@ -1208,7 +1310,7 @@ function lowerSwitchGroups(stmt, rawToStructured) {
     if (sawDefault) {
       throw new import_extractor.UnmodeledFlow("default clause is not last");
     }
-    if (import_ts_morph7.Node.isDefaultClause(clause)) {
+    if (import_ts_morph8.Node.isDefaultClause(clause)) {
       sawDefault = true;
       const stmts2 = clause.getStatements();
       if (stmts2.length === 0) {
@@ -1216,11 +1318,11 @@ function lowerSwitchGroups(stmt, rawToStructured) {
       }
       groups.push({
         condition: null,
-        ...lowerGroupBody(stmts2, rawToStructured)
+        ...lowerGroupBody(stmts2, ctx)
       });
       continue;
     }
-    if (!import_ts_morph7.Node.isCaseClause(clause)) {
+    if (!import_ts_morph8.Node.isCaseClause(clause)) {
       continue;
     }
     pendingLabels.push(clause.getExpression().getText());
@@ -1233,7 +1335,7 @@ function lowerSwitchGroups(stmt, rawToStructured) {
     const sourceText = labels.map((l) => `${switchText} === ${l}`).join(" || ");
     groups.push({
       condition: { sourceText, expression: null },
-      ...lowerGroupBody(stmts, rawToStructured)
+      ...lowerGroupBody(stmts, ctx)
     });
   }
   return groups;
@@ -1241,41 +1343,42 @@ function lowerSwitchGroups(stmt, rawToStructured) {
 function validateClauseBreaks(stmts) {
   const last = stmts[stmts.length - 1];
   for (const stmt of stmts) {
-    if (stmt === last && import_ts_morph7.Node.isBreakStatement(stmt)) {
+    if (stmt === last && import_ts_morph8.Node.isBreakStatement(stmt)) {
       continue;
     }
-    if (import_ts_morph7.Node.isSwitchStatement(stmt) || isLoop(stmt)) {
+    if (import_ts_morph8.Node.isSwitchStatement(stmt) || isLoop(stmt)) {
       continue;
     }
     stmt.forEachDescendant((node, traversal) => {
-      if (isFunctionBoundary(node) || import_ts_morph7.Node.isSwitchStatement(node) || isLoop(node)) {
+      if (startsItsOwnScope(node) || import_ts_morph8.Node.isSwitchStatement(node) || isLoop(node)) {
         traversal.skip();
         return;
       }
-      if (import_ts_morph7.Node.isBreakStatement(node)) {
+      if (import_ts_morph8.Node.isBreakStatement(node)) {
         throw new import_extractor.UnmodeledFlow("non-trailing break in switch clause");
       }
     });
-    if (import_ts_morph7.Node.isBreakStatement(stmt)) {
+    if (import_ts_morph8.Node.isBreakStatement(stmt)) {
       throw new import_extractor.UnmodeledFlow("non-trailing break in switch clause");
     }
   }
 }
-function lowerGroupBody(rawStmts, rawToStructured) {
+function lowerGroupBody(rawStmts, ctx) {
   const stmts = spliceBlocks(rawStmts);
   validateClauseBreaks(stmts);
   const last = stmts[stmts.length - 1];
-  const hasTrailingBreak = last !== void 0 && import_ts_morph7.Node.isBreakStatement(last);
+  const hasTrailingBreak = last !== void 0 && import_ts_morph8.Node.isBreakStatement(last);
   const kept = hasTrailingBreak ? stmts.slice(0, -1) : stmts;
-  const body = lowerList(kept, rawToStructured);
+  const body = lowerList(kept, ctx);
   if (hasTrailingBreak && last !== void 0) {
-    lowerStatement(last, rawToStructured);
+    lowerStatement(last, ctx);
   }
   return { hasTrailingBreak, body };
 }
-function lowerFunctionBody(body, terminalNodes) {
+function lowerFunctionBody(body, terminalNodes, func = body, barriers = NO_BARRIERS) {
   const rawToStructured = /* @__PURE__ */ new Map();
-  const statements = lowerList(body.getStatements(), rawToStructured);
+  const ctx = { func, barriers, rawToStructured };
+  const statements = lowerList(body.getStatements(), ctx);
   const terminalsByStmt = /* @__PURE__ */ new Map();
   const terminalHomeRaw = /* @__PURE__ */ new Map();
   for (const terminal of terminalNodes) {
@@ -1297,7 +1400,7 @@ function lowerFunctionBody(body, terminalNodes) {
 function enclosingLoweredStatement(terminal, body, rawToStructured) {
   let current2 = terminal;
   while (current2 !== void 0 && current2 !== body) {
-    if (import_ts_morph7.Node.isStatement(current2) && rawToStructured.has(current2)) {
+    if (import_ts_morph8.Node.isStatement(current2) && rawToStructured.has(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -1306,39 +1409,42 @@ function enclosingLoweredStatement(terminal, body, rawToStructured) {
 }
 
 // src/paths/pathConditions.ts
-function containsUnmodeledFlow(body) {
+function containsUnmodeledFlow(body, func, barriers) {
   let found = false;
   body.forEachDescendant((node, traversal) => {
-    if (isFunctionBoundary(node)) {
+    if (isDescentStop(node, func, barriers)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph8.Node.isLabeledStatement(node)) {
+    if (import_ts_morph9.Node.isLabeledStatement(node)) {
       found = true;
       traversal.stop();
     }
   });
   return found;
 }
-function computePathConditions(func, terminalNodes) {
+function loweredExpressionBody(body, terminalNodes, func, barriers) {
+  const statement = {
+    kind: "opaque",
+    exitKind: null,
+    callbacks: lowerExpressionBodyCallbacks(body, func, barriers)
+  };
+  return {
+    statements: [statement],
+    terminalsByStmt: /* @__PURE__ */ new Map([[statement, terminalNodes]]),
+    terminalHomeRaw: /* @__PURE__ */ new Map()
+  };
+}
+function computePathConditions(func, terminalNodes, barriers = NO_BARRIERS) {
   const body = func.getBody();
   if (body === void 0) {
     return { byTerminal: /* @__PURE__ */ new Map(), fallthrough: [] };
   }
-  if (!import_ts_morph8.Node.isBlock(body)) {
-    const byTerminal = /* @__PURE__ */ new Map();
-    for (const terminal of terminalNodes) {
-      byTerminal.set(terminal, [
-        collectAncestorConditionInfosBelow(terminal, func)
-      ]);
-    }
-    return { byTerminal, fallthrough: [] };
-  }
-  if (containsUnmodeledFlow(body)) {
+  if (containsUnmodeledFlow(body, func, barriers)) {
     return degradedResult(func, terminalNodes, "labeled statement");
   }
   try {
-    const lowered = lowerFunctionBody(body, terminalNodes);
+    const lowered = import_ts_morph9.Node.isBlock(body) ? lowerFunctionBody(body, terminalNodes, func, barriers) : loweredExpressionBody(body, terminalNodes, func, barriers);
     const result = (0, import_extractor2.enumerateStructuredPaths)({
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
@@ -1405,12 +1511,12 @@ function lineAt(node, pos) {
 }
 
 // src/moduleExports.ts
-var import_ts_morph10 = require("ts-morph");
+var import_ts_morph11 = require("ts-morph");
 
 // src/bootstrap/lazyProjectInit.ts
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_ts_morph9 = require("ts-morph");
+var import_ts_morph10 = require("ts-morph");
 
 // src/facts/moduleGraph.ts
 var import_datalog = require("@suss/datalog");
@@ -1538,7 +1644,7 @@ var ModuleGraph = class {
     return created;
   }
   assert(relation, tuple) {
-    if (this.db.add(relation, tuple)) {
+    if (this.db.add(relation, tuple) === "added") {
       this.stale = true;
     }
   }
@@ -1755,8 +1861,8 @@ function loadImportGraphsDepthFirstFromPaths(project, rootPaths) {
       stack.pop();
       loadOrder.push(top.path);
       let deepest = 0;
-      for (const path11 of top.deps) {
-        deepest = Math.max(deepest, chainDepth.get(path11) ?? 0);
+      for (const path12 of top.deps) {
+        deepest = Math.max(deepest, chainDepth.get(path12) ?? 0);
       }
       chainDepth.set(top.path, deepest + 1);
     }
@@ -1828,10 +1934,10 @@ function readSpecifierPaths(project, filePath, options, host) {
   if (text === null) {
     return [];
   }
-  const scanned = import_ts_morph9.ts.preProcessFile(text, true, true);
+  const scanned = import_ts_morph10.ts.preProcessFile(text, true, true);
   const paths = [];
   for (const imported of scanned.importedFiles) {
-    const resolved = import_ts_morph9.ts.resolveModuleName(
+    const resolved = import_ts_morph10.ts.resolveModuleName(
       imported.fileName,
       filePath,
       options,
@@ -1855,13 +1961,13 @@ function readFileText(project, filePath) {
   }
 }
 function parseTsconfig(tsConfigFilePath) {
-  const configFile = import_ts_morph9.ts.readConfigFile(tsConfigFilePath, import_ts_morph9.ts.sys.readFile);
+  const configFile = import_ts_morph10.ts.readConfigFile(tsConfigFilePath, import_ts_morph10.ts.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
   }
-  const parsed = import_ts_morph9.ts.parseJsonConfigFileContent(
+  const parsed = import_ts_morph10.ts.parseJsonConfigFileContent(
     configFile.config,
-    import_ts_morph9.ts.sys,
+    import_ts_morph10.ts.sys,
     import_node_path.default.dirname(tsConfigFilePath),
     /*existingOptions*/
     void 0,
@@ -1921,17 +2027,17 @@ function addImportersOfMatches(fileImports, matched, options) {
 }
 function internalSpecifierResolver(files, options) {
   const fileSet = new Set(files);
-  const cache = import_ts_morph9.ts.createModuleResolutionCache(
-    import_ts_morph9.ts.sys.getCurrentDirectory(),
+  const cache = import_ts_morph10.ts.createModuleResolutionCache(
+    import_ts_morph10.ts.sys.getCurrentDirectory(),
     (name) => name,
     options
   );
   return (fromFile, spec) => {
-    const resolved = import_ts_morph9.ts.resolveModuleName(
+    const resolved = import_ts_morph10.ts.resolveModuleName(
       spec,
       fromFile,
       options,
-      import_ts_morph9.ts.sys,
+      import_ts_morph10.ts.sys,
       cache
     ).resolvedModule?.resolvedFileName;
     if (resolved === void 0) {
@@ -1940,7 +2046,7 @@ function internalSpecifierResolver(files, options) {
     if (fileSet.has(resolved)) {
       return resolved;
     }
-    const real = import_ts_morph9.ts.sys.realpath?.(resolved) ?? resolved;
+    const real = import_ts_morph10.ts.sys.realpath?.(resolved) ?? resolved;
     return fileSet.has(real) ? real : null;
   };
 }
@@ -1966,7 +2072,7 @@ async function readImportsConcurrently(paths) {
       const p = paths[i];
       try {
         const text = await import_promises.default.readFile(p, "utf-8");
-        const pre = import_ts_morph9.ts.preProcessFile(text, true, false);
+        const pre = import_ts_morph10.ts.preProcessFile(text, true, false);
         results[i] = {
           path: p,
           importedModules: pre.importedFiles.map((f) => f.fileName)
@@ -1984,6 +2090,30 @@ async function readImportsConcurrently(paths) {
   return results;
 }
 
+// src/depTracking.ts
+function createDependencySink() {
+  return { files: /* @__PURE__ */ new Set(), mountPrefixes: /* @__PURE__ */ new Map(), claims: [] };
+}
+var activeSink = null;
+function withDependencySink(sink, fn) {
+  const previous = activeSink;
+  activeSink = sink;
+  try {
+    return fn();
+  } finally {
+    activeSink = previous;
+  }
+}
+function recordFileDependency(filePath) {
+  activeSink?.files.add(filePath);
+}
+function recordMountPrefix(childId, prefix) {
+  activeSink?.mountPrefixes.set(childId, prefix);
+}
+function recordUnitClaim(key, pack) {
+  activeSink?.claims.push({ key, pack });
+}
+
 // src/perFileCache.ts
 function createPerFileCache() {
   const byParse = /* @__PURE__ */ new WeakMap();
@@ -1999,6 +2129,7 @@ function createPerFileCache() {
 
 // src/moduleExports.ts
 function exportedDeclarationsOf(sourceFile) {
+  recordFileDependency(sourceFile.getFilePath());
   const cached = exportsByFile.get(sourceFile);
   if (cached !== void 0) {
     return cached;
@@ -2013,7 +2144,14 @@ function resolveAliasedSymbol(symbol) {
     warmReExportChains(declaration.getSourceFile(), "every import");
   }
   try {
-    return symbol.getAliasedSymbol();
+    const aliased = symbol.getAliasedSymbol();
+    for (const declaration of aliased?.getDeclarations() ?? []) {
+      const file = declaration.getSourceFile();
+      if (!file.isInNodeModules()) {
+        recordFileDependency(file.getFilePath());
+      }
+    }
+    return aliased;
   } catch (error) {
     if (!(error instanceof RangeError)) {
       throw error;
@@ -2069,11 +2207,11 @@ function walkAndWarm(root, reach) {
       if (warmedFiles.get(target) !== void 0) {
         continue;
       }
-      const path11 = target.getFilePath();
-      if (visited.has(path11)) {
+      const path12 = target.getFilePath();
+      if (visited.has(path12)) {
         continue;
       }
-      visited.add(path11);
+      visited.add(path12);
       stack.push(frameOf(target, reach));
       continue;
     }
@@ -2090,7 +2228,7 @@ function sitsOnWarmChains(file) {
     return false;
   }
   const imported = importedFilePathsOf(project, file.getFilePath());
-  return imported.length > 0 && imported.every((path11) => warmed.has(path11));
+  return imported.length > 0 && imported.every((path12) => warmed.has(path12));
 }
 function markWarmed(file) {
   warmedFiles.set(file, true);
@@ -2128,7 +2266,7 @@ function reExportShapeOf(file, reach) {
   for (const assignment of file.getExportAssignments()) {
     exportNodes.push(assignment);
     const expression = assignment.getExpression();
-    if (import_ts_morph10.Node.isIdentifier(expression)) {
+    if (import_ts_morph11.Node.isIdentifier(expression)) {
       localNames.add(expression.getText());
     }
   }
@@ -2204,38 +2342,6 @@ function reportUnreadableExports(file) {
   );
 }
 
-// src/walk/descent.ts
-var import_ts_morph11 = require("ts-morph");
-var NO_BARRIERS = /* @__PURE__ */ new Set();
-function isDescentStop(node, func, barriers = NO_BARRIERS) {
-  if (node === func) {
-    return false;
-  }
-  if (import_ts_morph11.Node.isFunctionDeclaration(node) || import_ts_morph11.Node.isMethodDeclaration(node)) {
-    return true;
-  }
-  if (import_ts_morph11.Node.isArrowFunction(node) || import_ts_morph11.Node.isFunctionExpression(node)) {
-    return barriers.has(node);
-  }
-  return false;
-}
-function isModuleScopeStop(node) {
-  return import_ts_morph11.Node.isFunctionDeclaration(node) || import_ts_morph11.Node.isMethodDeclaration(node) || import_ts_morph11.Node.isArrowFunction(node) || import_ts_morph11.Node.isFunctionExpression(node) || import_ts_morph11.Node.isClassDeclaration(node) || import_ts_morph11.Node.isClassExpression(node);
-}
-function crossesNestedFunctionScope(node, func) {
-  let current2 = node;
-  while (current2 !== void 0 && current2 !== func) {
-    if (startsItsOwnScope(current2)) {
-      return true;
-    }
-    current2 = current2.getParent();
-  }
-  return false;
-}
-function startsItsOwnScope(node) {
-  return import_ts_morph11.Node.isArrowFunction(node) || import_ts_morph11.Node.isFunctionExpression(node) || import_ts_morph11.Node.isFunctionDeclaration(node) || import_ts_morph11.Node.isMethodDeclaration(node) || import_ts_morph11.Node.isGetAccessorDeclaration(node) || import_ts_morph11.Node.isSetAccessorDeclaration(node) || import_ts_morph11.Node.isConstructorDeclaration(node);
-}
-
 // src/resolve/invocationEffects.ts
 function isImportedFrom(identifier, expectedModule) {
   if (!import_ts_morph12.Node.isIdentifier(identifier)) {
@@ -2255,14 +2361,38 @@ function isImportedFrom(identifier, expectedModule) {
     (decl) => decl.getSourceFile().getFilePath().includes(`/node_modules/${expectedModule}/`)
   );
 }
-function methodDeclaredIn(callee, expectedModule) {
+function methodDeclaredIn(callee, expectedModule, resolve2) {
   if (!import_ts_morph12.Node.isPropertyAccessExpression(callee)) {
     return false;
   }
   const declarations = callee.getNameNode().getSymbol()?.getDeclarations();
-  return declarations !== void 0 && declarations.some(
+  if (declarations !== void 0 && declarations.some(
     (declaration) => declaration.getSourceFile().getFilePath().includes(`/node_modules/${expectedModule}/`)
-  );
+  )) {
+    return true;
+  }
+  if (resolve2 === void 0) {
+    return false;
+  }
+  const written = resolve2(callee.getExpression());
+  const made = maker(written);
+  return made !== null && isImportedFrom(rootIdentifier(made), expectedModule);
+}
+function maker(written) {
+  if (written === null) {
+    return null;
+  }
+  if (import_ts_morph12.Node.isNewExpression(written) || import_ts_morph12.Node.isCallExpression(written)) {
+    return written.getExpression();
+  }
+  return null;
+}
+function rootIdentifier(expression) {
+  let root = expression;
+  while (import_ts_morph12.Node.isPropertyAccessExpression(root)) {
+    root = root.getExpression();
+  }
+  return root;
 }
 function importSpecifierMatches(decl, expectedModule) {
   if (import_ts_morph12.Node.isImportSpecifier(decl)) {
@@ -2342,6 +2472,26 @@ function extractInvocationEffects(func, barriers = NO_BARRIERS) {
       }
       return;
     }
+    if (import_ts_morph12.Node.isReturnStatement(node)) {
+      const returned = node.getExpression();
+      const { call, async } = returned === void 0 ? { call: null, async: false } : unwrapCall(returned);
+      if (call !== null) {
+        const preconditions = collectPreconditions(node, func);
+        results.push({
+          effect: {
+            type: "invocation",
+            callee: call.getExpression().getText(),
+            args: extractArgs(call),
+            async,
+            ...preconditions.length > 0 ? { preconditions } : {}
+          },
+          line: startLineOf(node),
+          neverTerminal: false,
+          node: call
+        });
+      }
+      return;
+    }
     if (import_ts_morph12.Node.isCallExpression(node)) {
       const parent = node.getParent();
       if (parent === void 0) {
@@ -4940,7 +5090,8 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
   ];
   const { byTerminal } = computePathConditions(
     func,
-    terminals.map(({ node }) => node)
+    terminals.map(({ node }) => node),
+    barriers
   );
   const wantsFallthrough = terminalPatterns.some(
     (p) => p.match.type === "functionFallthrough"
@@ -4952,7 +5103,11 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
     if (!hasDefaultTerminal) {
       const synthetic = makeFallthroughTerminal(func);
       terminals.push(synthetic);
-      const pathResult = computePathConditions(func, [synthetic.node]);
+      const pathResult = computePathConditions(
+        func,
+        [synthetic.node],
+        barriers
+      );
       byTerminal.set(
         synthetic.node,
         pathResult.fallthrough.length > 0 ? pathResult.fallthrough : [[]]
@@ -4998,7 +5153,10 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
       const terminalLines = new Set(
         distinctBranches.map((b) => b.terminal.location.start)
       );
-      defaultBranch.effects = invocations.filter((i) => i.neverTerminal || !terminalLines.has(i.line)).map((i) => i.effect);
+      const terminalNodes = new Set(terminals.map(({ node }) => node));
+      defaultBranch.effects = invocations.filter(
+        (i) => i.node !== void 0 ? !terminalNodes.has(i.node) : i.neverTerminal || !terminalLines.has(i.line)
+      ).map((i) => i.effect);
     }
   }
   if (recognized.length > 0) {
@@ -5043,9 +5201,9 @@ function createSourceFileLookup(project) {
       if (sf === null) {
         return null;
       }
-      const path11 = sf.getFilePath();
-      const index = functionsByFile.get(path11) ?? indexFunctions(sf);
-      functionsByFile.set(path11, index);
+      const path12 = sf.getFilePath();
+      const index = functionsByFile.get(path12) ?? indexFunctions(sf);
+      functionsByFile.set(path12, index);
       return index.get(rangeKey(location.range)) ?? null;
     }
   };
@@ -5083,7 +5241,7 @@ function indexFunctions(sf) {
 var import_node_crypto2 = require("crypto");
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var SCHEMA_VERSION = "5";
+var SCHEMA_VERSION = "6";
 var MAX_ENTRIES = 2;
 var ENTRY_PREFIX = "key-";
 var ENTRY_DIR_NAME = new RegExp(`^${ENTRY_PREFIX}[0-9a-f]{16}$`);
@@ -5095,6 +5253,7 @@ function createCacheLayer(cacheDir) {
         kind: "miss",
         diagnostic: { kind: "miss", missReason: "no-manifest" }
       }),
+      plan: async () => null,
       write: async () => {
       }
     };
@@ -5125,17 +5284,32 @@ function createCacheLayer(cacheDir) {
         diagnostic: { kind: "hit" }
       };
     },
-    async write(input, summaries) {
+    async plan(input) {
+      const entryDir = entryDirFor(cacheDir, input);
+      const manifest = await readManifest(import_node_path2.default.join(entryDir, "manifest.json"));
+      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0 || manifest.owners === void 0) {
+        return null;
+      }
+      const currentTsconfigStamp = await stampTsconfig(input.tsconfigPath);
+      if (!fileStampEquals(manifest.tsconfigStamp, currentTsconfigStamp)) {
+        return null;
+      }
+      await markUsed(entryDir);
+      return buildPlan(manifest, await resolveFileStamps(input));
+    },
+    async write(input, summaries, attribution) {
+      const entryDir = entryDirFor(cacheDir, input);
+      const previous = await readManifest(import_node_path2.default.join(entryDir, "manifest.json"));
       const tsconfigStamp = await stampTsconfig(input.tsconfigPath);
-      const files = await resolveFileStamps(input);
+      const files = await hashStamps(await resolveFileStamps(input), previous);
       const manifest = {
         schemaVersion: SCHEMA_VERSION,
         adapterPacksDigest: input.adapterPacksDigest,
         tsconfigStamp,
         files,
-        summaries
+        summaries,
+        ...attribution === void 0 ? {} : encodeAttribution(attribution)
       };
-      const entryDir = entryDirFor(cacheDir, input);
       await import_promises2.default.mkdir(entryDir, { recursive: true });
       await import_promises2.default.writeFile(
         import_node_path2.default.join(entryDir, "manifest.json"),
@@ -5145,6 +5319,163 @@ function createCacheLayer(cacheDir) {
     }
   };
 }
+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);
+      }
+    }
+  }
+  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, record] of roots) {
+    if (!record.cacheable || !current2.has(rootPath)) {
+      continue;
+    }
+    if (changed.has(rootPath)) {
+      continue;
+    }
+    const depMoved = record.deps.some((d) => changed.has(d) || removed.has(d));
+    if (!depMoved) {
+      validRoots.add(rootPath);
+    }
+  }
+  const owners = manifest.owners ?? [];
+  return {
+    changed,
+    removed,
+    roots,
+    validRoots,
+    rootsDeclined,
+    reuse(valid) {
+      const summaries = [];
+      const reusedOwners = [];
+      manifest.summaries.forEach((summary, i) => {
+        const ownerPaths = (owners[i] ?? []).flatMap((o) => {
+          const p = rootNames[o];
+          return p === void 0 ? [] : [p];
+        });
+        if (ownerPaths.some((p) => valid.has(p))) {
+          summaries.push(summary);
+          reusedOwners.push(ownerPaths.filter((p) => valid.has(p)));
+        }
+      });
+      return { summaries, owners: reusedOwners };
+    },
+    allSummaries() {
+      return manifest.summaries;
+    },
+    attribution() {
+      return {
+        roots: [...roots.values()],
+        owners: owners.map(
+          (ownerIds) => ownerIds.flatMap((o) => {
+            const p = rootNames[o];
+            return p === void 0 ? [] : [p];
+          })
+        )
+      };
+    }
+  };
+}
+function encodeAttribution(attribution) {
+  const roots = attribution.roots.map((r) => r.path);
+  const rootIndex = new Map(roots.map((p, i) => [p, i]));
+  const depIndex = /* @__PURE__ */ new Map();
+  const depPaths = [];
+  const depIdOf = (p) => {
+    const existing = depIndex.get(p);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const id = depPaths.length;
+    depPaths.push(p);
+    depIndex.set(p, id);
+    return id;
+  };
+  const rootMeta = attribution.roots.map((r) => ({
+    cacheable: r.cacheable,
+    deps: r.deps.map(depIdOf),
+    claims: r.claims,
+    mountPrefixes: r.mountPrefixes,
+    packs: r.packs
+  }));
+  const owners = attribution.owners.map(
+    (ownerPaths) => ownerPaths.flatMap((p) => {
+      const i = rootIndex.get(p);
+      return i === void 0 ? [] : [i];
+    })
+  );
+  return { roots, rootMeta, depPaths, owners };
+}
+async function hashStamps(stamps, previous) {
+  const before = new Map((previous?.files ?? []).map((f) => [f.path, f]));
+  return Promise.all(
+    stamps.map(async (stamp) => {
+      const prior = before.get(stamp.path);
+      if (prior !== void 0 && prior.contentHash !== void 0 && fileStampEquals(prior, stamp)) {
+        return { ...stamp, contentHash: prior.contentHash };
+      }
+      const contentHash = await hashFile(stamp.path);
+      return contentHash === null ? stamp : { ...stamp, contentHash };
+    })
+  );
+}
+async function hashFile(filePath) {
+  try {
+    const content = await import_promises2.default.readFile(filePath);
+    return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+  } catch {
+    return null;
+  }
+}
 async function describeAbsentEntry(cacheDir) {
   try {
     const entries = await import_promises2.default.readdir(cacheDir, { withFileTypes: true });
@@ -5158,7 +5489,7 @@ function entryDirFor(cacheDir, input) {
     SCHEMA_VERSION,
     input.adapterPacksDigest,
     input.tsconfigPath ?? ""
-  ].join("\0");
+  ].join(" ");
   const name = (0, import_node_crypto2.createHash)("sha256").update(key).digest("hex").slice(0, 16);
   return import_node_path2.default.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
@@ -5399,7 +5730,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   }
   const responses = [];
   let method;
-  let path11;
+  let path12;
   for (const prop of endpointNode.getProperties()) {
     if (!import_ts_morph25.Node.isPropertyAssignment(prop)) {
       continue;
@@ -5414,7 +5745,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
     if (propName === pattern.pathProperty) {
       const val = prop.getInitializer();
       if (val !== void 0 && import_ts_morph25.Node.isStringLiteral(val)) {
-        path11 = val.getLiteralValue();
+        path12 = val.getLiteralValue();
       }
     }
     if (propName === pattern.responseExtraction.property) {
@@ -5438,10 +5769,10 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   if (responses.length === 0) {
     return null;
   }
-  const boundaryBinding = method !== void 0 || path11 !== void 0 ? (0, import_behavioral_ir.restBinding)({
+  const boundaryBinding = method !== void 0 || path12 !== void 0 ? (0, import_behavioral_ir.restBinding)({
     transport: "http",
     method: method ?? null,
-    path: path11 ?? null,
+    path: path12 ?? null,
     recognition: framework
   }) : null;
   return {
@@ -6025,6 +6356,13 @@ function literalIndexOf(index) {
   }
   return null;
 }
+function asFallbackExpression(expression) {
+  if (!import_ts_morph28.Node.isBinaryExpression(expression)) {
+    return null;
+  }
+  const operator = expression.getOperatorToken().getKind();
+  return operator === import_ts_morph28.SyntaxKind.BarBarToken || operator === import_ts_morph28.SyntaxKind.QuestionQuestionToken ? expression : null;
+}
 function unwrapExpression(expression) {
   let current2 = expression;
   for (; ; ) {
@@ -6136,6 +6474,12 @@ function emitValue(db, table, value) {
     }
     return id;
   }
+  const fallback = asFallbackExpression(expression);
+  if (fallback !== null) {
+    fact(db, "fallbackBranch", id, emitValue(db, table, fallback.getLeft()));
+    fact(db, "fallbackBranch", id, emitValue(db, table, fallback.getRight()));
+    return id;
+  }
   if (import_ts_morph28.Node.isCallExpression(expression) || import_ts_morph28.Node.isNewExpression(expression)) {
     emitCallFacts(db, table, expression);
     fact(db, "writtenValue", id);
@@ -6600,24 +6944,27 @@ function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const sole = soleGraphqlClientRef(
     collectGraphqlClientRefs(sourceFiles, packs, resolution)
   );
-  if (sole === null && scopes.length === 0) {
-    return;
-  }
   const workspace = sole !== null ? boundWorkspaceFor(sole, packs) : null;
   const soleClient = sole !== null ? workspace !== null ? { ...sole, workspace } : sole : null;
+  let registry = null;
   for (const summary of summaries) {
     if (!(0, import_behavioral_ir3.isGraphqlOperationBinding)(summary.identity.boundaryBinding)) {
       continue;
     }
+    const existing = (0, import_behavioral_ir3.readGraphqlMetadata)(summary) ?? {};
     const scoped = scopedWorkspaceFor(summary.location.file, scopes);
     const client = scoped !== null ? { uri: null, uriRef: null, workspace: scoped } : soleClient;
-    if (client === null) {
+    const dangling = (existing.unresolvedFragments?.length ?? 0) > 0;
+    if (client === null && !dangling) {
       continue;
     }
-    const existing = (0, import_behavioral_ir3.readGraphqlMetadata)(summary) ?? {};
+    if (dangling && registry === null) {
+      registry = fragmentRegistryStatus(sourceFiles, packs);
+    }
     summary.metadata = (0, import_behavioral_ir3.withGraphqlMetadata)(summary.metadata, {
       ...existing,
-      client
+      ...client !== null ? { client } : {},
+      ...dangling && registry !== null ? { fragmentRegistry: registry } : {}
     });
   }
 }
@@ -6683,48 +7030,198 @@ function soleGraphqlClientRef(refs) {
   }
   return [...distinct.values()][0] ?? null;
 }
-function localNamesFor(sourceFile, specs) {
-  const names = /* @__PURE__ */ new Map();
-  for (const importDecl of sourceFile.getImportDeclarations()) {
-    const module2 = importDecl.getModuleSpecifierValue();
-    for (const spec of specs) {
-      if (module2 !== spec.importModule) {
+function fragmentRegistryStatus(sourceFiles, packs) {
+  const statuses = [];
+  for (const spec of packs.flatMap((pack) => pack.graphqlClients ?? [])) {
+    const registrySpec = spec.fragmentRegistry;
+    if (registrySpec === void 0) {
+      continue;
+    }
+    for (const sourceFile of sourceFiles) {
+      const local = localImportName(
+        sourceFile,
+        spec.importModule,
+        spec.importName
+      );
+      if (local === null) {
         continue;
       }
-      for (const named2 of importDecl.getNamedImports()) {
-        if (named2.getName() !== spec.importName) {
-          continue;
+      sourceFile.forEachDescendant((node) => {
+        if (isConstructionNamed(node, local)) {
+          statuses.push(constructionRegistryStatus(node, registrySpec));
         }
-        const local = named2.getAliasNode()?.getText() ?? named2.getName();
-        names.set(local, spec.uriProperty);
-      }
+      });
     }
   }
-  return names;
+  return combineRegistryStatuses(statuses);
 }
-function constructionRef(node, localNames, resolution) {
-  if (!import_ts_morph30.Node.isNewExpression(node) && !import_ts_morph30.Node.isCallExpression(node)) {
-    return null;
+function combineRegistryStatuses(statuses) {
+  if (statuses.includes("configured")) {
+    return "configured";
   }
-  const callee = node.getExpression();
-  if (callee === void 0 || !import_ts_morph30.Node.isIdentifier(callee)) {
-    return null;
+  if (statuses.length === 0 || statuses.includes("unknown")) {
+    return "unknown";
   }
-  const uriProperty = localNames.get(callee.getText());
-  if (uriProperty === void 0) {
-    return null;
+  return "absent";
+}
+function constructionRegistryStatus(construction, spec) {
+  const options = firstArgumentObjectLiteral(construction);
+  if (options === null) {
+    return "unknown";
   }
-  const optionsArg = node.getArguments()[0];
-  if (optionsArg === void 0 || !import_ts_morph30.Node.isObjectLiteralExpression(optionsArg)) {
-    return null;
+  const cacheExpr = propertyValueOf2(options, spec.cacheProperty);
+  if (cacheExpr === null) {
+    return "unknown";
   }
-  const property = optionsArg.getProperty(uriProperty);
-  if (property === void 0 || !import_ts_morph30.Node.isPropertyAssignment(property)) {
-    return null;
+  const cacheConstruction = resolveToConstructionOf(
+    cacheExpr,
+    spec.cacheConstructor
+  );
+  if (cacheConstruction === null) {
+    return "unknown";
   }
-  const value = property.getInitializer();
-  if (value === void 0) {
-    return null;
+  if (!import_ts_morph30.Node.isNewExpression(cacheConstruction) && !import_ts_morph30.Node.isCallExpression(cacheConstruction)) {
+    return "unknown";
+  }
+  const args = cacheConstruction.getArguments();
+  if (args.length === 0) {
+    return "absent";
+  }
+  const cacheOptions = firstArgumentObjectLiteral(cacheConstruction);
+  if (cacheOptions === null) {
+    return "unknown";
+  }
+  if (cacheOptions.getProperty(spec.registryProperty) !== void 0) {
+    return "configured";
+  }
+  const hasSpread = cacheOptions.getProperties().some((property) => import_ts_morph30.Node.isSpreadAssignment(property));
+  return hasSpread ? "unknown" : "absent";
+}
+function firstArgumentObjectLiteral(construction) {
+  if (!import_ts_morph30.Node.isNewExpression(construction) && !import_ts_morph30.Node.isCallExpression(construction)) {
+    return null;
+  }
+  const arg = construction.getArguments()[0];
+  if (arg === void 0 || !import_ts_morph30.Node.isObjectLiteralExpression(arg)) {
+    return null;
+  }
+  return arg;
+}
+function propertyValueOf2(options, name) {
+  const property = options.getProperty(name);
+  if (property === void 0) {
+    return null;
+  }
+  if (import_ts_morph30.Node.isPropertyAssignment(property)) {
+    return property.getInitializer() ?? null;
+  }
+  if (import_ts_morph30.Node.isShorthandPropertyAssignment(property)) {
+    const symbol = property.getProject().getTypeChecker().getShorthandAssignmentValueSymbol(property);
+    return symbol?.getValueDeclaration() ?? null;
+  }
+  return null;
+}
+function resolveToConstructionOf(expression, cacheClass) {
+  let current2 = expression;
+  for (let hop = 0; hop < 4 && current2 !== void 0; hop += 1) {
+    current2 = unwrapExpression2(current2);
+    if (import_ts_morph30.Node.isVariableDeclaration(current2)) {
+      current2 = current2.getInitializer();
+      continue;
+    }
+    if (import_ts_morph30.Node.isNewExpression(current2) || import_ts_morph30.Node.isCallExpression(current2)) {
+      const callee = current2.getExpression();
+      if (callee === void 0 || !import_ts_morph30.Node.isIdentifier(callee)) {
+        return null;
+      }
+      const local = localImportName(
+        current2.getSourceFile(),
+        cacheClass.importModule,
+        cacheClass.importName
+      );
+      return local !== null && callee.getText() === local ? current2 : null;
+    }
+    if (!import_ts_morph30.Node.isIdentifier(current2)) {
+      return null;
+    }
+    const declaration = current2.getSymbol()?.getValueDeclaration();
+    if (declaration === void 0 || !import_ts_morph30.Node.isVariableDeclaration(declaration)) {
+      return null;
+    }
+    current2 = declaration.getInitializer();
+  }
+  return null;
+}
+function unwrapExpression2(node) {
+  let current2 = node;
+  while (import_ts_morph30.Node.isParenthesizedExpression(current2) || import_ts_morph30.Node.isAsExpression(current2) || import_ts_morph30.Node.isNonNullExpression(current2)) {
+    current2 = current2.getExpression();
+  }
+  return current2;
+}
+function isConstructionNamed(node, localName) {
+  if (!import_ts_morph30.Node.isNewExpression(node) && !import_ts_morph30.Node.isCallExpression(node)) {
+    return false;
+  }
+  const callee = node.getExpression();
+  return callee !== void 0 && import_ts_morph30.Node.isIdentifier(callee) && callee.getText() === localName;
+}
+function localImportName(sourceFile, importModule, importName) {
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const module2 = importDecl.getModuleSpecifierValue();
+    if (module2 !== importModule && !module2.startsWith(`${importModule}/`)) {
+      continue;
+    }
+    for (const named2 of importDecl.getNamedImports()) {
+      if (named2.getName() === importName) {
+        return named2.getAliasNode()?.getText() ?? named2.getName();
+      }
+    }
+  }
+  return null;
+}
+function localNamesFor(sourceFile, specs) {
+  const names = /* @__PURE__ */ new Map();
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const module2 = importDecl.getModuleSpecifierValue();
+    for (const spec of specs) {
+      if (module2 !== spec.importModule) {
+        continue;
+      }
+      for (const named2 of importDecl.getNamedImports()) {
+        if (named2.getName() !== spec.importName) {
+          continue;
+        }
+        const local = named2.getAliasNode()?.getText() ?? named2.getName();
+        names.set(local, spec.uriProperty);
+      }
+    }
+  }
+  return names;
+}
+function constructionRef(node, localNames, resolution) {
+  if (!import_ts_morph30.Node.isNewExpression(node) && !import_ts_morph30.Node.isCallExpression(node)) {
+    return null;
+  }
+  const callee = node.getExpression();
+  if (callee === void 0 || !import_ts_morph30.Node.isIdentifier(callee)) {
+    return null;
+  }
+  const uriProperty = localNames.get(callee.getText());
+  if (uriProperty === void 0) {
+    return null;
+  }
+  const optionsArg = node.getArguments()[0];
+  if (optionsArg === void 0 || !import_ts_morph30.Node.isObjectLiteralExpression(optionsArg)) {
+    return null;
+  }
+  const property = optionsArg.getProperty(uriProperty);
+  if (property === void 0 || !import_ts_morph30.Node.isPropertyAssignment(property)) {
+    return null;
+  }
+  const value = property.getInitializer();
+  if (value === void 0) {
+    return null;
   }
   const literal = stringValueOf(value, resolution);
   if (literal !== null) {
@@ -7010,7 +7507,7 @@ function calleeOf(decorator) {
 
 // src/discovery/decoratedMethod.ts
 function resolverTypeName(args) {
-  return args.classTypeName ?? args.typeMap[args.decoratorName] ?? null;
+  return args.typeMap[args.decoratorName] ?? args.classTypeName ?? null;
 }
 function resolveResolverClassTypeName(decoratorArg) {
   if (import_ts_morph34.Node.isArrowFunction(decoratorArg)) {
@@ -7424,32 +7921,163 @@ function innerTemplateText(template) {
   }
   return raw;
 }
-function resolveGraphqlDocument(arg, resolution) {
-  const stripped = stripDocumentNodeCasts(arg);
-  const inline = documentTextFromExpression(stripped);
+function startAssembly(resolution) {
+  return {
+    resolution,
+    seen: /* @__PURE__ */ new Set(),
+    unresolvedInterpolations: [],
+    unresolvedInsideSelection: false
+  };
+}
+function assembledTemplateText(template, assembly) {
+  if (import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(template)) {
+    return innerTemplateText(template);
+  }
+  if (!import_ts_morph37.Node.isTemplateExpression(template)) {
+    return null;
+  }
+  let text = template.getHead().getLiteralText();
+  for (const span of template.getTemplateSpans()) {
+    const spliced = interpolatedDocumentText(span.getExpression(), assembly);
+    if (spliced === null) {
+      assembly.unresolvedInterpolations.push(
+        singleLine(span.getExpression().getText())
+      );
+      if (openBraceDepth(text) > 0) {
+        assembly.unresolvedInsideSelection = true;
+      }
+    } else {
+      text += `
+${spliced}
+`;
+    }
+    text += span.getLiteral().getLiteralText();
+  }
+  return text;
+}
+function openBraceDepth(text) {
+  let depth = 0;
+  for (const char of text) {
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+    }
+  }
+  return depth;
+}
+function interpolatedDocumentText(expr, assembly) {
+  const stripped = stripDocumentNodeCasts(expr);
+  const inline = documentTextFromExpression(stripped, assembly);
   if (inline !== null) {
-    return { document: inline };
+    return inline;
   }
-  const templateText = resolveGqlTemplateText(stripped);
-  if (templateText !== null) {
-    return { document: templateText };
+  const named2 = resolveGqlTemplateText(stripped, assembly);
+  if (named2 !== null) {
+    return named2;
   }
   const objectDoc = resolveTypedDocumentSource(stripped);
   if (objectDoc !== null) {
-    return { document: objectDoc };
+    return objectDoc;
   }
-  const throughFacts = resolveThroughFacts(stripped, resolution);
-  if (throughFacts !== null) {
-    return { document: throughFacts };
+  return resolveThroughFacts(stripped, assembly);
+}
+function resolveGraphqlDocument(arg, resolution) {
+  const assembly = startAssembly(resolution);
+  const stripped = stripDocumentNodeCasts(arg);
+  const text = documentTextFromExpression(stripped, assembly) ?? resolveGqlTemplateText(stripped, assembly) ?? resolveTypedDocumentSource(stripped) ?? resolveThroughFacts(stripped, assembly);
+  if (text !== null) {
+    return assembledDocumentResolution(text, stripped, assembly);
   }
   return resolveTypedDocumentHeader(stripped);
 }
-function documentTextFromExpression(node) {
+function assembledDocumentResolution(text, arg, assembly) {
+  const interpolations = assembly.unresolvedInterpolations;
+  if (assembly.unresolvedInsideSelection) {
+    const header = parseGraphqlOperation(text);
+    return {
+      ...header !== null ? { operationType: header.operationType } : {},
+      ...header?.operationName !== void 0 ? { operationName: header.operationName } : {},
+      unresolved: {
+        reference: singleLine(arg.getText()),
+        reason: `interpolated ${describeInterpolations(interpolations)} inside a selection set did not resolve to a GraphQL document, so what the operation selects is not statically written`
+      }
+    };
+  }
+  const dangling = danglingFragmentSpreads(text);
+  if (dangling === null) {
+    if (interpolations.length === 0) {
+      return { document: text };
+    }
+    return {
+      unresolved: {
+        reference: singleLine(arg.getText()),
+        reason: `the document did not parse after dropping interpolated ${describeInterpolations(interpolations)} that resolved to no GraphQL document`
+      }
+    };
+  }
+  if (dangling.length > 0) {
+    return { document: text, unresolvedFragments: dangling };
+  }
+  if (interpolations.length > 0) {
+    return {
+      document: text,
+      unresolved: {
+        reference: singleLine(arg.getText()),
+        reason: `interpolated ${describeInterpolations(interpolations)} did not resolve to a GraphQL document, so whatever it contributes is not part of the stored document`
+      }
+    };
+  }
+  return { document: text };
+}
+function describeInterpolations(interpolations) {
+  const quoted = interpolations.map((text) => `\`${text}\``).join(", ");
+  return interpolations.length === 1 ? `expression ${quoted}` : `expressions ${quoted}`;
+}
+function danglingFragmentSpreads(text) {
+  let doc;
+  try {
+    doc = (0, import_graphql.parse)(text);
+  } catch {
+    return null;
+  }
+  const defined = /* @__PURE__ */ new Set();
+  for (const def of doc.definitions) {
+    if (def.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
+      defined.add(def.name.value);
+    }
+  }
+  const dangling = /* @__PURE__ */ new Set();
+  for (const def of doc.definitions) {
+    if (def.kind === import_graphql.Kind.OPERATION_DEFINITION || def.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
+      collectDanglingSpreads(def.selectionSet, defined, dangling);
+    }
+  }
+  return [...dangling].sort();
+}
+function collectDanglingSpreads(selectionSet, defined, dangling) {
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === import_graphql.Kind.FRAGMENT_SPREAD) {
+      if (!defined.has(selection.name.value)) {
+        dangling.add(selection.name.value);
+      }
+      continue;
+    }
+    if (selection.selectionSet !== void 0) {
+      collectDanglingSpreads(selection.selectionSet, defined, dangling);
+    }
+  }
+}
+function documentTextFromExpression(node, assembly) {
   if (import_ts_morph37.Node.isTaggedTemplateExpression(node)) {
     if (!isDocumentTag(node.getTag())) {
       return null;
     }
-    return innerTemplateText(node.getTemplate());
+    if (assembly.seen.has(node)) {
+      return "";
+    }
+    assembly.seen.add(node);
+    return assembledTemplateText(node.getTemplate(), assembly);
   }
   if (!import_ts_morph37.Node.isCallExpression(node)) {
     return null;
@@ -7465,7 +8093,11 @@ function documentTextFromExpression(node) {
   if (!import_ts_morph37.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph37.Node.isTemplateExpression(template)) {
     return null;
   }
-  return innerTemplateText(template);
+  if (assembly.seen.has(node)) {
+    return "";
+  }
+  assembly.seen.add(node);
+  return assembledTemplateText(template, assembly);
 }
 function isDocumentTag(tag) {
   if (!import_ts_morph37.Node.isIdentifier(tag)) {
@@ -7485,15 +8117,15 @@ function isDocumentTag(tag) {
   }
   return false;
 }
-function resolveThroughFacts(arg, resolution) {
-  if (resolution === void 0 || !import_ts_morph37.Node.isIdentifier(arg)) {
+function resolveThroughFacts(arg, assembly) {
+  if (assembly.resolution === void 0 || !import_ts_morph37.Node.isIdentifier(arg)) {
     return null;
   }
-  const written = resolution.resolveWrittenValue(arg);
+  const written = assembly.resolution.resolveWrittenValue(arg);
   if (written === null) {
     return null;
   }
-  const text = documentTextFromExpression(written);
+  const text = documentTextFromExpression(written, assembly);
   if (text !== null) {
     return text;
   }
@@ -7506,7 +8138,13 @@ function operationInfoFromResolution(resolution, callOperationType) {
       return null;
     }
     const operationType = operation.operationName !== void 0 ? operation.operationType : callOperationType;
-    return { ...operation, operationType, document: resolution.document };
+    return {
+      ...operation,
+      operationType,
+      document: resolution.document,
+      ...resolution.unresolvedFragments !== void 0 ? { unresolvedFragments: resolution.unresolvedFragments } : {},
+      ...resolution.unresolved !== void 0 ? { unresolved: resolution.unresolved } : {}
+    };
   }
   return {
     operationType: resolution.operationType ?? callOperationType,
@@ -7548,8 +8186,8 @@ function importedVariableInitializers(identifier) {
   }
   return inits;
 }
-function resolveGqlTemplateText(arg) {
-  const direct = documentTextFromExpression(arg);
+function resolveGqlTemplateText(arg, assembly) {
+  const direct = documentTextFromExpression(arg, assembly);
   if (direct !== null) {
     return direct;
   }
@@ -7569,7 +8207,10 @@ function resolveGqlTemplateText(arg) {
     }
   }
   for (const init of importedVariableInitializers(arg)) {
-    const text = documentTextFromExpression(stripDocumentNodeCasts(init));
+    const text = documentTextFromExpression(
+      stripDocumentNodeCasts(init),
+      assembly
+    );
     if (text !== null) {
       return text;
     }
@@ -8157,14 +8798,14 @@ function unitForJsxRoute(node, match, routeNames, kind, resolution) {
   }
   return routeUnit(node, kind, match.method, resolved.path, target, resolution);
 }
-function routeUnit(at, kind, method, path11, target, resolution) {
-  const routeInfo = { method, path: path11 };
+function routeUnit(at, kind, method, path12, target, resolution) {
+  const routeInfo = { method, path: path12 };
   if (target.kind === "unreadable") {
     return {
       func: null,
       announcedAt: at,
       kind,
-      name: path11,
+      name: path12,
       nameKind: "label",
       routeInfo
     };
@@ -9052,9 +9693,9 @@ function withMountPrefix(routeInfo, subjectNode, mountPrefixes) {
   const prefix = mountPrefixes.effectivePrefixFor(subjectNode);
   return prefix === "" ? routeInfo : { ...routeInfo, path: joinMountedPath(prefix, routeInfo.path) };
 }
-function joinMountedPath(prefix, path11) {
+function joinMountedPath(prefix, path12) {
   const trimmed = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  return trimmed === "" ? path11 : trimmed + path11;
+  return trimmed === "" ? path12 : trimmed + path12;
 }
 function registrationSubjectsOf(sourceFile, importModule, importName) {
   let importedLocalName = null;
@@ -9218,11 +9859,11 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
       return null;
     }
     const method2 = stringProperty(routeObject, binding.method.property);
-    const path11 = stringProperty(routeObject, binding.path.property);
-    if (method2 === null || path11 === null) {
+    const path12 = stringProperty(routeObject, binding.path.property);
+    if (method2 === null || path12 === null) {
       return null;
     }
-    return { method: method2.toUpperCase(), path: path11 };
+    return { method: method2.toUpperCase(), path: path12 };
   }
   if (binding.method.type !== "fromRegistration" || binding.path.type !== "fromRegistration") {
     return null;
@@ -9329,7 +9970,7 @@ function bodyReferencesLoopVar(loop, name) {
 }
 function readRouteSpec(element, shape, resolution) {
   let method = null;
-  let path11 = null;
+  let path12 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
     if (import_ts_morph46.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
@@ -9347,16 +9988,16 @@ function readRouteSpec(element, shape, resolution) {
     if (name === shape.methodKey) {
       method = readStringLiteralValue(init);
     } else if (name === shape.pathKey) {
-      path11 = readStringLiteralValue(init);
+      path12 = readStringLiteralValue(init);
     } else if (name === shape.handlerKey) {
       const func = functionValueOf(init, resolution);
       handler = func === null ? null : { func, name: handlerName(init) };
     }
   }
-  if (method === null || path11 === null || handler === null) {
+  if (method === null || path12 === null || handler === null) {
     return null;
   }
-  return { method, path: path11, handler: handler.func, handlerName: handler.name };
+  return { method, path: path12, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
   if (import_ts_morph46.Node.isStringLiteral(node) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(node)) {
@@ -9385,8 +10026,8 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
     }
     const args = node.getArguments();
     for (const reg of match.registrations) {
-      const path11 = substitutePath(reg.pathTemplate, args);
-      if (path11 === null) {
+      const path12 = substitutePath(reg.pathTemplate, args);
+      if (path12 === null) {
         continue;
       }
       const handler = resolveHandler(reg.handlerArg, args, resolution);
@@ -9399,7 +10040,7 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
         name: handler.name,
         routeInfo: {
           method: reg.method.toUpperCase(),
-          path: path11
+          path: path12
         }
       });
     }
@@ -9568,7 +10209,10 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
           resolverInfo: {
             typeName,
             fieldName,
-            ...schemaSdl !== null ? { schemaSdl } : {}
+            ...schemaSdl !== null ? {
+              schemaSdl,
+              schemaDocument: config.getSourceFile().getFilePath()
+            } : {}
           }
         });
       }
@@ -9765,7 +10409,15 @@ function discoverUnits(sourceFile, patterns, resolution, mountPrefixes) {
 }
 
 // src/discovery/mountPrefix.ts
-var NO_MOUNTS = { effectivePrefixFor: () => "" };
+var NO_MOUNTS = {
+  // Recorded even with no mounts anywhere: a mount added later in some
+  // other file changes this router's prefix without touching its file.
+  effectivePrefixFor: (routerNode) => {
+    recordMountPrefix(nodeId(routerNode), "");
+    return "";
+  },
+  prefixForId: () => ""
+};
 function buildMountPrefixIndex(packsByFile, resolution) {
   const subjectIdsByPack = /* @__PURE__ */ new Map();
   const mountWorkByPack = /* @__PURE__ */ new Map();
@@ -9822,10 +10474,15 @@ function buildMountPrefixIndex(packsByFile, resolution) {
     return NO_MOUNTS;
   }
   const memo = /* @__PURE__ */ new Map();
+  const byId = (childId) => resolvePrefix(edgesByChild, memo, childId, /* @__PURE__ */ new Set()) ?? "";
   return {
     effectivePrefixFor(routerNode) {
-      return resolvePrefix(edgesByChild, memo, nodeId(routerNode), /* @__PURE__ */ new Set()) ?? "";
-    }
+      const childId = nodeId(routerNode);
+      const prefix = byId(childId);
+      recordMountPrefix(childId, prefix);
+      return prefix;
+    },
+    prefixForId: byId
   };
 }
 function recordEdge(edgesByChild, candidate) {
@@ -10071,7 +10728,8 @@ var JS_RULES = [
   (0, import_datalog2.rule)(
     "stepsTo",
     [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t"), import_resolution.VALUE_STEP],
-    [(0, import_datalog2.lit)("bindCall", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t"))]
+    [(0, import_datalog2.lit)("bindCall", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t"))],
+    "bind"
   )
 ];
 var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
@@ -10081,6 +10739,15 @@ var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
   [...import_resolution.RESOLUTION_RULES, ...JS_RULES, ...import_resolution.RESOLUTION_QUESTIONS],
   import_resolution.ANSWER_RELATIONS
 );
+var WITNESS_RULES = [...import_resolution.RESOLUTION_RULES, ...JS_RULES];
+var NOT_BASE_FACTS = /* @__PURE__ */ new Set([
+  ...[...import_resolution.RESOLUTION_RULES, ...JS_RULES, ...import_resolution.RESOLUTION_QUESTIONS].map(
+    (r) => r.head.relation
+  ),
+  ...RESOLUTION_PROGRAM.rules.map((r) => r.head.relation),
+  "wanted",
+  "wantedOrigin"
+]);
 var QUERY_FACTS = RESOLUTION_PROGRAM.demandDriven.length === 0 ? [] : [...RESOLUTION_PROGRAM.demandDriven, "wanted", "wantedOrigin"];
 var MAX_MODULE_HOPS = 6;
 var ResolutionStore = class {
@@ -10089,6 +10756,8 @@ var ResolutionStore = class {
   fullyExtracted = /* @__PURE__ */ new Set();
   seededValues = /* @__PURE__ */ new Set();
   importedNames = /* @__PURE__ */ new Map();
+  /** Files the most recent wave walk entered, for the memo to keep. */
+  lastQueryWalked = [];
   declarations = /* @__PURE__ */ new Map();
   graph = new ModuleGraph();
   stale = true;
@@ -10106,13 +10775,64 @@ var ResolutionStore = class {
    * the walk never reaches on its own.
    */
   resolveCallable(value, alsoFrom) {
+    const sources = this.resolveCallableSources(value, alsoFrom);
+    const only = sources[0];
+    return sources.length === 1 && only !== void 0 ? only : null;
+  }
+  /**
+   * Every function the value comes down to. One is the answer
+   * `resolveCallable` gives; several is a value with more than one
+   * possible source, which a caller says at the site rather than
+   * folding into the same nothing as a chain that went nowhere.
+   */
+  resolveCallableSources(value, alsoFrom) {
     const target = factKeyOf(value);
     return this.resolveByWaves(
       target,
       "wanted",
-      () => this.lookup(target),
+      () => 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.
+   */
+  explainCallable(value, options = {}) {
+    const resolved = this.resolveCallable(value, options.alsoFrom);
+    if (resolved === null) {
+      return null;
+    }
+    const proofDb = new import_datalog2.Database();
+    let baseFacts = 0;
+    for (const relation of this.db.relationNames()) {
+      if (NOT_BASE_FACTS.has(relation)) {
+        continue;
+      }
+      for (const tuple of this.db.facts(relation)) {
+        proofDb.add(relation, tuple);
+        baseFacts++;
+      }
+    }
+    const started = performance.now();
+    (0, import_datalog2.evaluate)(proofDb, WITNESS_RULES, import_datalog2.witnesses);
+    const evaluateMs = performance.now() - started;
+    const derivedFacts = proofDb.relationNames().reduce((count, relation) => count + proofDb.size(relation), 0) - baseFacts;
+    const proof = (0, import_datalog2.proofOf)(
+      proofDb,
+      "resolves",
+      [nodeId(factKeyOf(value)), nodeId(resolved)],
+      options.maxDepth === void 0 ? {} : { maxDepth: options.maxDepth }
     );
+    return {
+      target: resolved,
+      proof,
+      nodeFor: (atom) => this.table.byId.get(String(atom)),
+      stats: { baseFacts, derivedFacts, evaluateMs }
+    };
   }
   resolveObject(value) {
     const target = factKeyOf(value);
@@ -10149,7 +10869,10 @@ var ResolutionStore = class {
     const declaration = `${nodeId(refersTo)}|${modules.join(",")}`;
     const cached = this.importedNames.get(declaration);
     if (cached !== void 0) {
-      return cached;
+      for (const walkedPath of cached.walked) {
+        recordFileDependency(walkedPath);
+      }
+      return cached.names;
     }
     const target = factKeyOf(value);
     const found = this.resolveByWaves(
@@ -10157,7 +10880,10 @@ var ResolutionStore = class {
       "wantedOrigin",
       () => this.lookupImportedNames(target, modules)
     ) ?? [];
-    this.importedNames.set(declaration, found);
+    this.importedNames.set(declaration, {
+      names: found,
+      walked: [...this.lastQueryWalked]
+    });
     return found;
   }
   /**
@@ -10191,6 +10917,7 @@ var ResolutionStore = class {
     this.wantValue(question, value);
     this.seedValue(value);
     const walked = /* @__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 = [];
@@ -10199,6 +10926,8 @@ var ResolutionStore = class {
           continue;
         }
         walked.add(sourceFile.getFilePath());
+        this.lastQueryWalked.push(sourceFile.getFilePath());
+        recordFileDependency(sourceFile.getFilePath());
         this.extractFile(sourceFile);
         next.push(...this.graph.importedFilesOf(sourceFile));
       }
@@ -10226,7 +10955,7 @@ var ResolutionStore = class {
     this.stale = false;
   }
   wantValue(question, value) {
-    if (this.db.add(question, [nodeId(value)])) {
+    if (this.db.add(question, [nodeId(value)]) === "added") {
       this.stale = true;
     }
   }
@@ -10290,10 +11019,12 @@ var ResolutionStore = class {
     return this.graph.filesReachingAnyPackage(fileSets);
   }
   /**
-   * Two candidates give null. Picking whichever arrived first would make
-   * the result depend on the order the facts came in.
+   * 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.
    */
-  lookup(value) {
+  lookupSources(value) {
     this.derive();
     const candidates = /* @__PURE__ */ new Set();
     for (const target of this.answersFor("wantedResolves", nodeId(value))) {
@@ -10305,10 +11036,7 @@ var ResolutionStore = class {
         candidates.add(resolved);
       }
     }
-    if (candidates.size !== 1) {
-      return null;
-    }
-    return [...candidates][0];
+    return candidates.size === 0 ? null : [...candidates];
   }
   derive() {
     if (!this.stale) {
@@ -10495,6 +11223,27 @@ function moduleInitSummary(sourceFile, effects, options) {
   return (0, import_extractor3.assembleSummary)(raw, options);
 }
 
+// src/referencedFiles.ts
+function createReferenceIndex(sourceFiles) {
+  const direct = /* @__PURE__ */ new Map();
+  for (const sourceFile of sourceFiles) {
+    const referenced = /* @__PURE__ */ new Set();
+    for (const target of sourceFile.getReferencedSourceFiles()) {
+      if (target.isInNodeModules() || target.isDeclarationFile()) {
+        continue;
+      }
+      referenced.add(target.getFilePath());
+    }
+    direct.set(sourceFile.getFilePath(), referenced);
+  }
+  const none = /* @__PURE__ */ new Set();
+  return {
+    directOf(filePath) {
+      return direct.get(filePath) ?? none;
+    }
+  };
+}
+
 // src/resolve/boundaryEffects.ts
 var import_datalog3 = require("@suss/datalog");
 var EFFECT_RULES = [
@@ -10676,6 +11425,11 @@ function classifyStop(declarations) {
   if (declarations.length === 0) {
     return "noDeclaration";
   }
+  for (const declaration of declarations) {
+    if (!isInExternalCode(declaration.getSourceFile())) {
+      recordFileDependency(declaration.getSourceFile().getFilePath());
+    }
+  }
   if (declarations.every(isExternalDeclaration)) {
     return "outsideRun";
   }
@@ -10687,6 +11441,7 @@ function classifyStop(declarations) {
 var RECORDED = {
   noBody: true,
   unsettledValue: true,
+  multipleSources: true,
   outsideRun: false,
   noDeclaration: false
 };
@@ -10696,6 +11451,7 @@ function worthRecording(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`
 };
@@ -10749,24 +11505,6 @@ function resolveDecl(decl, calleeName) {
     }
     return null;
   }
-  if (import_ts_morph52.Node.isImportSpecifier(decl)) {
-    const importDecl = decl.getImportDeclaration();
-    const sf = importDecl.getModuleSpecifierSourceFile();
-    if (sf === void 0 || isInExternalCode(sf)) {
-      return null;
-    }
-    const exported = exportedDeclarationsOf(sf).get(decl.getName());
-    if (exported === void 0) {
-      return null;
-    }
-    for (const ed of exported) {
-      const resolved = resolveDecl(ed, calleeName);
-      if (resolved !== null) {
-        return resolved;
-      }
-    }
-    return null;
-  }
   return null;
 }
 function declName(decl) {
@@ -10794,20 +11532,27 @@ function resolveCallee(call, calleeName, scan) {
   }
   const callee = call.getExpression();
   const symbol = callee.getSymbol();
-  const declarations = symbol?.getDeclarations() ?? [];
+  const declarations = declarationsBehind(symbol);
   for (const decl of declarations) {
     const resolved = resolveDecl(decl, calleeName);
     if (resolved !== null) {
       return { kind: "followed", candidate: resolved };
     }
   }
-  const resolveCallable = scan.resolveCallable;
-  if (resolveCallable !== void 0 && import_ts_morph52.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
-    const value = resolveCallable(callee, scan.reachedFrom);
-    const resolved = value === null ? null : resolveDecl(value, calleeName);
+  const resolveSources = scan.resolveCallableSources;
+  if (resolveSources !== void 0 && import_ts_morph52.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+    const sources = resolveSources(callee, scan.reachedFrom);
+    const only = sources.length === 1 ? sources[0] : void 0;
+    const resolved = only === void 0 ? null : resolveDecl(only, calleeName);
     if (resolved !== null) {
       return { kind: "followed", candidate: resolved };
     }
+    if (sources.length > 1) {
+      return {
+        kind: "stopped",
+        stop: { callee: calleeName, reason: "multipleSources" }
+      };
+    }
   }
   return {
     kind: "stopped",
@@ -10882,7 +11627,7 @@ var REACHABLE_RULES = [
   )
 ];
 var NO_RECOGNIZERS = { invocation: [], access: [] };
-function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS) {
+function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS, alreadySummarized = []) {
   const lookup = createSourceFileLookup(project);
   const db = facts?.db ?? new import_datalog4.Database();
   const functionByKey = /* @__PURE__ */ new Map();
@@ -10902,6 +11647,15 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       db.add("entry", [key]);
     }
   }
+  const knownKeys = /* @__PURE__ */ new Set();
+  for (const summary of alreadySummarized) {
+    const func = lookup.functionAt(summary.location);
+    if (func !== null) {
+      const key = nodeKey2(func);
+      knownKeys.add(key);
+      facts?.unitKeyBySummary.set(summary, key);
+    }
+  }
   for (; ; ) {
     (0, import_datalog4.evaluate)(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
@@ -10916,10 +11670,14 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       }
       const cameFrom = reachedFrom.get(key);
       const scan = {
-        ...recognizers.resolveCallable === void 0 ? {} : { resolveCallable: recognizers.resolveCallable },
+        ...recognizers.resolveCallableSources === void 0 ? {} : { resolveCallableSources: recognizers.resolveCallableSources },
         ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
       };
-      const { candidates, stops } = collectReachable(source.func, scan);
+      const { candidates, stops } = scanWithRecording(
+        key,
+        facts,
+        () => collectReachable(source.func, scan)
+      );
       if (stops.length > 0) {
         stopsByKey.set(key, stops);
       }
@@ -10938,7 +11696,7 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
   const reached = [];
   for (const [keyAtom] of db.facts("reachable")) {
     const key = String(keyAtom);
-    if (seedKeys.has(key)) {
+    if (seedKeys.has(key) || knownKeys.has(key)) {
       continue;
     }
     const candidate = functionByKey.get(key);
@@ -10952,7 +11710,11 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
         candidate.func.getSourceFile().getFilePath()
       );
     }
-    const summary = extractReachableSummary(candidate, options, recognizers);
+    const summary = scanWithRecording(
+      key,
+      facts,
+      () => extractReachableSummary(candidate, options, recognizers)
+    );
     facts?.unitKeyBySummary.set(summary, key);
     rememberSummary(summariesByKey, key, summary);
     reached.push(summary);
@@ -10960,6 +11722,20 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
   recordStops(stopsByKey, summariesByKey, options);
   return [...seeds, ...reached];
 }
+function scanWithRecording(key, facts, fn) {
+  const filesByKey = facts?.filesByKey;
+  if (filesByKey === void 0) {
+    return fn();
+  }
+  const sink = createDependencySink();
+  const result = withDependencySink(sink, fn);
+  const bucket = filesByKey.get(key) ?? /* @__PURE__ */ new Set();
+  for (const filePath of sink.files) {
+    bucket.add(filePath);
+  }
+  filesByKey.set(key, bucket);
+  return result;
+}
 function rememberSummary(summariesByKey, key, summary) {
   const bucket = summariesByKey.get(key) ?? [];
   bucket.push(summary);
@@ -11708,20 +12484,25 @@ function readArrayLiteralText(node) {
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
+function workspaceRootFor(anchor) {
+  return namedPackageDirAbove(anchor) ?? import_node_path7.default.resolve(anchor);
+}
 function workspaceNameFor(root) {
   if (root === void 0) {
     return null;
   }
-  let at = import_node_path7.default.resolve(root);
+  const dir = namedPackageDirAbove(root);
+  if (dir !== null) {
+    return packageNameAt(dir);
+  }
+  const folder = import_node_path7.default.basename(import_node_path7.default.resolve(root));
+  return folder.length > 0 ? folder : null;
+}
+function namedPackageDirAbove(start) {
+  let at = import_node_path7.default.resolve(start);
   for (let up = 0; up < 12; up += 1) {
-    try {
-      const manifest = JSON.parse(
-        import_node_fs4.default.readFileSync(import_node_path7.default.join(at, "package.json"), "utf8")
-      );
-      if (typeof manifest.name === "string" && manifest.name.length > 0) {
-        return manifest.name;
-      }
-    } catch {
+    if (packageNameAt(at) !== null) {
+      return at;
     }
     const parent = import_node_path7.default.dirname(at);
     if (parent === at) {
@@ -11729,8 +12510,19 @@ function workspaceNameFor(root) {
     }
     at = parent;
   }
-  const folder = import_node_path7.default.basename(import_node_path7.default.resolve(root));
-  return folder.length > 0 ? folder : null;
+  return null;
+}
+function packageNameAt(dir) {
+  try {
+    const manifest = JSON.parse(
+      import_node_fs4.default.readFileSync(import_node_path7.default.join(dir, "package.json"), "utf8")
+    );
+    if (typeof manifest.name === "string" && manifest.name.length > 0) {
+      return manifest.name;
+    }
+  } catch {
+  }
+  return null;
 }
 function nameSummaries(summaries, args) {
   for (const summary of summaries) {
@@ -12215,6 +13007,36 @@ function extractCodeStructure(unit, pack, invocationRecognizers = [], accessReco
 function responseAccessorNames(pack, kind) {
   return pack.responseSemantics?.filter((m) => m.semantics.type === kind).map((m) => m.name);
 }
+var ACCESSOR_FIELD_SEMANTICS = {
+  bodyAccessors: "body",
+  statusAccessors: "statusCode",
+  successAccessors: "statusRange"
+};
+function responseAccessors(pack) {
+  const out = {};
+  for (const [field, kind] of Object.entries(ACCESSOR_FIELD_SEMANTICS)) {
+    const names = responseAccessorNames(pack, kind);
+    if (names !== void 0 && names.length > 0) {
+      out[field] = names;
+    }
+  }
+  return out;
+}
+var FUNCTION_FALLTHROUGH_TERMINAL = {
+  kind: "return",
+  match: { type: "functionFallthrough" },
+  extraction: {}
+};
+function terminalsFor(unit, pack) {
+  const declared = unit.terminals ?? pack.terminals;
+  if (unit.callSite === void 0) {
+    return declared;
+  }
+  if (declared.some((p) => p.match.type === "functionFallthrough")) {
+    return declared;
+  }
+  return [...declared, FUNCTION_FALLTHROUGH_TERMINAL];
+}
 function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers, barriers, resolveWrittenValue) {
   const { func, kind, name } = unit;
   if (func === null) {
@@ -12226,7 +13048,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
   );
   const extracted = extractRawBranches(
     func,
-    unit.terminals ?? pack.terminals,
+    terminalsFor(unit, pack),
     invocationRecognizers,
     accessRecognizers,
     barriers,
@@ -12262,8 +13084,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
       }
     }
   }
-  const bodyAccessors = unit.callSite !== void 0 ? responseAccessorNames(pack, "body") : void 0;
-  const statusAccessors = unit.callSite !== void 0 ? responseAccessorNames(pack, "statusCode") : void 0;
+  const accessors = unit.callSite !== void 0 ? responseAccessors(pack) : {};
   return {
     identity: {
       name,
@@ -12287,8 +13108,8 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
     bodyContent: bodyContentOf(func),
     dependencyCalls: depCalls,
     declaredContract: null,
-    ...bodyAccessors !== void 0 && bodyAccessors.length > 0 ? { bodyAccessors } : {},
-    ...statusAccessors !== void 0 && statusAccessors.length > 0 ? { statusAccessors } : {}
+    ...accessors,
+    ...unit.callSite !== void 0 && pack.failureDelivery !== void 0 ? { failureDelivery: pack.failureDelivery } : {}
   };
 }
 function extractConsumerBinding(unit, pattern, pack, resolution) {
@@ -12301,11 +13122,11 @@ function extractConsumerBinding(unit, pattern, pack, resolution) {
     return null;
   }
   const method = extractBindingMethod(binding, callSite, pack, resolution);
-  const path11 = extractBindingPath(binding, callSite, pack, resolution);
+  const path12 = extractBindingPath(binding, callSite, pack, resolution);
   return (0, import_behavioral_ir6.restBinding)({
     transport: pack.protocol,
     method: method ?? null,
-    path: path11 ?? null,
+    path: path12 ?? null,
     recognition: pack.name
   });
 }
@@ -12394,12 +13215,12 @@ function originEndOf(flattened) {
   const slash = flattened.indexOf("/", opener[0].length);
   return slash === -1 ? flattened.length : slash;
 }
-function appendPathText(path11, text) {
+function appendPathText(path12, text) {
   const idx = text.search(/[?#]/);
   if (idx === -1) {
-    return { path: path11 + text, stop: false };
+    return { path: path12 + text, stop: false };
   }
-  return { path: path11 + text.slice(0, idx), stop: true };
+  return { path: path12 + text.slice(0, idx), stop: true };
 }
 function parseAbsoluteUrl(text) {
   try {
@@ -12423,8 +13244,8 @@ function pathnameOfAbsoluteLiteral(text) {
   return stripQueryAndFragment(stripOriginManually(text));
 }
 function pathFromLiteralUrl(text) {
-  const path11 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
-  return path11 === "" ? void 0 : path11;
+  const path12 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
+  return path12 === "" ? void 0 : path12;
 }
 function pathFromTemplateUrl(arg) {
   const headText = arg.getHead().getLiteralText();
@@ -12432,7 +13253,7 @@ function pathFromTemplateUrl(arg) {
   const tails = spans.map((span) => span.getLiteral().getLiteralText());
   const originEnd = originEndOf([headText, ...tails].join(SUBSTITUTION));
   const head = appendPathText("", headText.slice(originEnd));
-  let path11 = head.path;
+  let path12 = head.path;
   let stop = head.stop;
   let at = headText.length;
   for (let i = 0; i < spans.length && !stop; i++) {
@@ -12442,18 +13263,18 @@ function pathFromTemplateUrl(arg) {
       continue;
     }
     if (at >= originEnd) {
-      path11 += `{${placeholderName(span.getExpression())}}`;
+      path12 += `{${placeholderName(span.getExpression())}}`;
     }
     at += SUBSTITUTION.length;
     const appended = appendPathText(
-      path11,
+      path12,
       tailText.slice(Math.max(0, originEnd - at))
     );
-    path11 = appended.path;
+    path12 = appended.path;
     stop = appended.stop;
     at += tailText.length;
   }
-  return path11 === "" ? void 0 : path11;
+  return path12 === "" ? void 0 : path12;
 }
 function extractBindingPath(binding, callSite, pack, resolution) {
   const p = binding.path;
@@ -12642,12 +13463,20 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         if (claimant.pack === pack.name && claimant.file === sourceFile.getFilePath() && tally !== void 0) {
           tally.selfCollisions += 1;
         }
+        if (claimant.file !== sourceFile.getFilePath()) {
+          recordFileDependency(claimant.file);
+        }
         continue;
       }
       claimed.set(claimKey, {
         pack: pack.name,
         file: sourceFile.getFilePath()
       });
+      recordUnitClaim(claimKey, pack.name);
+      const declaringFile = unit.func?.getSourceFile().getFilePath();
+      if (declaringFile !== void 0 && declaringFile !== sourceFile.getFilePath()) {
+        recordFileDependency(declaringFile);
+      }
       unitsWalkedHere += 1;
       if (tally !== void 0) {
         tally.unitsClaimed += 1;
@@ -12686,6 +13515,9 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         }
         if (unit.resolverInfo.schemaSdl !== void 0) {
           raw.graphqlSchemaSdl = unit.resolverInfo.schemaSdl;
+          if (unit.resolverInfo.schemaDocument !== void 0) {
+            raw.sourceDocumentLabel = unit.resolverInfo.schemaDocument;
+          }
           if (unit.resolverInfo.typeName !== null) {
             const contract = deriveGraphqlContract(
               unit.resolverInfo.schemaSdl,
@@ -12721,6 +13553,9 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         if (unit.operationInfo.document !== void 0) {
           raw.graphqlDocument = unit.operationInfo.document;
         }
+        if (unit.operationInfo.unresolvedFragments !== void 0) {
+          raw.graphqlUnresolvedFragments = unit.operationInfo.unresolvedFragments;
+        }
         if (unit.operationInfo.unresolved !== void 0) {
           raw.graphqlUnresolvedDocument = unit.operationInfo.unresolved;
         }
@@ -12874,6 +13709,37 @@ function fileImporting(project, modulePrefix) {
   }
   return void 0;
 }
+function liftSchemasOntoDocuments(summaries) {
+  const sdlByDocument = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const label = (0, import_behavioral_ir6.readSourceDocumentMetadata)(summary)?.label;
+    const graphql = (0, import_behavioral_ir6.readGraphqlMetadata)(summary);
+    if (label === void 0 || graphql?.schemaSdl === void 0) {
+      continue;
+    }
+    sdlByDocument.set(label, graphql.schemaSdl);
+    const { schemaSdl: _movedToTheDocument, ...rest } = graphql;
+    summary.metadata = (0, import_behavioral_ir6.withGraphqlMetadata)(summary.metadata, rest);
+  }
+  for (const [label, schemaSdl] of sdlByDocument) {
+    summaries.push(schemaDocumentSummary(label, schemaSdl));
+  }
+}
+function schemaDocumentSummary(label, schemaSdl) {
+  return {
+    kind: "library",
+    location: { file: label, range: { start: 0, end: 0 }, exportName: null },
+    identity: { name: label, exportPath: null, boundaryBinding: null },
+    inputs: [],
+    transitions: [],
+    gaps: [],
+    confidence: { source: "declared", level: "high" },
+    metadata: (0, import_behavioral_ir6.withGraphqlMetadata)(
+      (0, import_behavioral_ir6.withSourceDocumentMetadata)(void 0, { label }),
+      { schemaSdl }
+    )
+  };
+}
 function libraryEnvReadMarker(pack, declared, importer) {
   return {
     kind: "library",
@@ -12991,8 +13857,8 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
     if (pathArg === void 0) {
       continue;
     }
-    const path11 = literalOrTemplate(pathArg);
-    if (path11 === void 0) {
+    const path12 = literalOrTemplate(pathArg);
+    if (path12 === void 0) {
       continue;
     }
     const callerFunc = enclosingFunction(callExpr);
@@ -13004,7 +13870,7 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
       continue;
     }
     seen.add(dedupKey);
-    out.push(buildCallerSummary(wrapper, callerFunc, callExpr, path11, options));
+    out.push(buildCallerSummary(wrapper, callerFunc, callExpr, path12, options));
   }
   return out;
 }
@@ -13056,12 +13922,12 @@ function literalOrTemplate(arg) {
     return arg.getLiteralValue();
   }
   if (import_ts_morph56.Node.isTemplateExpression(arg)) {
-    let path11 = arg.getHead().getLiteralText();
+    let path12 = arg.getHead().getLiteralText();
     for (const span of arg.getTemplateSpans()) {
-      path11 += `{${placeholderName(span.getExpression())}}`;
-      path11 += span.getLiteral().getLiteralText();
+      path12 += `{${placeholderName(span.getExpression())}}`;
+      path12 += span.getLiteral().getLiteralText();
     }
-    return path11;
+    return path12;
   }
   return void 0;
 }
@@ -13078,7 +13944,7 @@ function callerName(func) {
   }
   return "anonymous";
 }
-function buildCallerSummary(wrapper, callerFunc, callExpr, path11, options) {
+function buildCallerSummary(wrapper, callerFunc, callExpr, path12, options) {
   const wrapperBinding = wrapper.summary.identity.boundaryBinding;
   const wrapperRest = wrapperBinding?.semantics.name === "rest" ? wrapperBinding.semantics : null;
   const syntheticPack = {
@@ -13110,7 +13976,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path11, options) {
   raw.boundaryBinding = (0, import_behavioral_ir6.restBinding)({
     transport: wrapperBinding?.transport ?? "http",
     method: wrapperRest?.method ?? null,
-    path: path11,
+    path: path12,
     recognition: wrapperBinding?.recognition ?? "unknown"
   });
   const summary = (0, import_extractor5.assembleSummary)(raw, options);
@@ -13124,8 +13990,8 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path11, options) {
   summary.confidence = { source: "inferred_static", level: "low" };
   return summary;
 }
-function named(summaries, workspace) {
-  const projectRoot = commonDirectoryOf(summaries.map((s) => s.location.file));
+function named(summaries, workspace, runRoot) {
+  const projectRoot = runRoot ?? commonDirectoryOf(summaries.map((s) => s.location.file));
   nameSummaries(summaries, {
     workspace: workspace ?? workspaceNameFor(projectRoot),
     projectRoot
@@ -13183,6 +14049,7 @@ function createTypeScriptAdapter(config) {
       skipAddingFilesFromTsConfig: true
     } : { skipAddingFilesFromTsConfig: true }
   );
+  const runRoot = config.projectRoot ?? (config.tsConfigFilePath !== void 0 ? workspaceRootFor(import_node_path9.default.dirname(config.tsConfigFilePath)) : void 0);
   let lazyBootstrapped = false;
   let projectFileSet;
   const cacheDir = declineWhenRunFromSource(
@@ -13223,7 +14090,7 @@ function createTypeScriptAdapter(config) {
           )
         );
       }
-      return named(summaries, config.workspace);
+      return named(summaries, config.workspace, runRoot);
     },
     async extractAll() {
       const timer = createTimer();
@@ -13256,7 +14123,25 @@ function createTypeScriptAdapter(config) {
         if (config.onTiming !== void 0) {
           config.onTiming(timer.report());
         }
-        return named(lookup.summaries, config.workspace);
+        return named(lookup.summaries, config.workspace, runRoot);
+      }
+      const plan = lookup.diagnostic.missReason === "files-changed" ? await timer.timeAsync("cache.plan", () => cache.plan(cacheInput)) : null;
+      if (plan !== null && plan.changed.size === 0 && plan.removed.size === 0) {
+        try {
+          await cache.write(
+            cacheInput,
+            plan.allSummaries(),
+            plan.attribution()
+          );
+        } catch {
+        }
+        if (config.onCacheDiagnostic !== void 0) {
+          config.onCacheDiagnostic({ kind: "hit" });
+        }
+        if (config.onTiming !== void 0) {
+          config.onTiming(timer.report());
+        }
+        return named(plan.allSummaries(), config.workspace, runRoot);
       }
       let candidatePaths = null;
       if (lazyEligible) {
@@ -13287,16 +14172,58 @@ function createTypeScriptAdapter(config) {
         "mountPrefix",
         () => buildMountPrefixIndex(packsByFile, resolution)
       );
+      const caching = cacheDir !== null;
+      const validRoots = /* @__PURE__ */ new Set();
+      if (plan !== null) {
+        const packNamesByPath = /* @__PURE__ */ new Map();
+        for (const [sf, packs] of packsByFile) {
+          packNamesByPath.set(
+            sf.getFilePath(),
+            packs.map((p) => p.name).sort().join(",")
+          );
+        }
+        for (const rootPath of plan.validRoots) {
+          const record = plan.roots.get(rootPath);
+          if (record === void 0) {
+            continue;
+          }
+          if (!mountAssumptionsAgree(record, mountPrefixes)) {
+            continue;
+          }
+          const stored = [...record.packs].sort().join(",");
+          if ((packNamesByPath.get(rootPath) ?? "") !== stored) {
+            continue;
+          }
+          validRoots.add(rootPath);
+        }
+      }
+      const reused = plan !== null && validRoots.size > 0 ? plan.reuse(validRoots) : null;
       const claimedUnits = /* @__PURE__ */ new Map();
+      if (reused !== null && plan !== null) {
+        for (const rootPath of validRoots) {
+          for (const claim of plan.roots.get(rootPath)?.claims ?? []) {
+            claimedUnits.set(claim.key, { pack: claim.pack, file: rootPath });
+          }
+        }
+      }
+      const walkList = reused === null ? sourceFiles : sourceFiles.filter((sf) => !validRoots.has(sf.getFilePath()));
+      const sinkByRoot = /* @__PURE__ */ new Map();
+      const ownersBySummary = /* @__PURE__ */ new Map();
       timer.time("extract per-file", () => {
-        for (const sourceFile of sourceFiles) {
+        for (const sourceFile of walkList) {
+          const rootPath = sourceFile.getFilePath();
+          const sink = createDependencySink();
+          if (caching) {
+            sinkByRoot.set(rootPath, sink);
+          }
           const applicablePacks = packsByFile.get(sourceFile);
           if (applicablePacks === void 0) {
             continue;
           }
           try {
-            summaries.push(
-              ...extractFromSourceFile(
+            const walked = withDependencySink(
+              sink,
+              () => extractFromSourceFile(
                 sourceFile,
                 applicablePacks,
                 claimedUnits,
@@ -13306,6 +14233,10 @@ function createTypeScriptAdapter(config) {
                 mountPrefixes
               )
             );
+            for (const summary of walked) {
+              ownersBySummary.set(summary, /* @__PURE__ */ new Set([rootPath]));
+            }
+            summaries.push(...walked);
           } catch (error) {
             if (!(error instanceof RangeError)) {
               throw error;
@@ -13314,23 +14245,32 @@ function createTypeScriptAdapter(config) {
           }
         }
       });
+      const wrapperInput = reused === null ? summaries : [...summaries, ...reused.summaries];
       const withWrappers = timer.time(
         "expandWrapperCallers",
-        () => expandWrapperCallers(summaries, project, config.extractorOptions)
+        () => expandWrapperCallers(wrapperInput, project, config.extractorOptions)
       );
+      const pipeline = reused === null ? withWrappers : [...summaries, ...withWrappers.slice(wrapperInput.length)];
       const withSubUnits = timer.time(
         "synthesizeSubUnits",
         () => synthesizeSubUnits(
-          withWrappers,
+          pipeline,
           project,
           config.frameworks,
           config.extractorOptions,
-          tallies
+          tallies,
+          (created, parent) => {
+            const parentOwners = ownersBySummary.get(parent);
+            if (parentOwners !== void 0) {
+              ownersBySummary.set(created, new Set(parentOwners));
+            }
+          }
         )
       );
       const closureFacts = {
         db: new import_datalog6.Database(),
-        unitKeyBySummary: /* @__PURE__ */ new Map()
+        unitKeyBySummary: /* @__PURE__ */ new Map(),
+        ...caching ? { filesByKey: /* @__PURE__ */ new Map() } : {}
       };
       const withClosure = config.includeReachable !== false ? timer.time(
         "expandReachableClosure",
@@ -13347,13 +14287,29 @@ function createTypeScriptAdapter(config) {
             ),
             access: collectAccessRecognizers(config.frameworks, tallies),
             resolveWrittenValue: (value) => resolution.resolveWrittenValue(value),
-            resolveCallable: (value, alsoFrom) => resolution.resolveCallable(value, alsoFrom)
-          }
+            resolveCallableSources: (value, alsoFrom) => resolution.resolveCallableSources(value, alsoFrom)
+          },
+          // Reached units the cache already serves emit nothing,
+          // the way a cold run's seeds do not.
+          reused?.summaries ?? []
         )
       ) : withSubUnits;
+      const closureOwnership = caching && config.includeReachable !== false ? timer.time(
+        "cache.attributeClosure",
+        () => attributeReachedSummaries(
+          withSubUnits,
+          withClosure.slice(withSubUnits.length),
+          closureFacts,
+          ownersBySummary
+        )
+      ) : null;
+      const merged = timer.time(
+        "cache.merge",
+        () => mergeWithReused(reused, withClosure, ownersBySummary)
+      );
       const enriched = timer.time(
         "enrichRethrows",
-        () => enrichRethrows(withClosure, project, closureFacts)
+        () => enrichRethrows(merged.summaries, project, closureFacts)
       );
       if (config.includeReachable !== false) {
         timer.time(
@@ -13369,6 +14325,10 @@ function createTypeScriptAdapter(config) {
         "emitLibraryEnvReadMarkers",
         () => emitLibraryEnvReadMarkers(enriched, project, config.frameworks)
       );
+      timer.time(
+        "liftSchemasOntoDocuments",
+        () => liftSchemasOntoDocuments(enriched)
+      );
       timer.time(
         "stampGraphqlClientRefs",
         () => stampGraphqlClientRefs(
@@ -13378,12 +14338,41 @@ function createTypeScriptAdapter(config) {
           resolution
         )
       );
+      if (config.onCacheDiagnostic !== void 0 && plan !== null) {
+        config.onCacheDiagnostic({
+          kind: "partial",
+          partial: {
+            filesChanged: plan.changed.size,
+            filesRemoved: plan.removed.size,
+            rootsReused: validRoots.size,
+            rootsReextracted: walkList.length,
+            rootsDeclined: plan.rootsDeclined,
+            summariesReused: merged.reusedKept.length
+          }
+        });
+      }
       await timer.timeAsync("cache.write", async () => {
-        if (enriched.length === 0) {
+        if (!caching || enriched.length === 0) {
           return;
         }
         try {
-          await cache.write(cacheInput, enriched);
+          const attribution = buildCacheAttribution({
+            project,
+            plan,
+            validRoots,
+            sinkByRoot,
+            ownersBySummary,
+            closureOwnership,
+            unitKeyBySummary: closureFacts.unitKeyBySummary,
+            filesByKey: closureFacts.filesByKey,
+            packsByFile,
+            reusedKept: merged.reusedKept,
+            reusedOwners: merged.reusedOwners,
+            // Everything after the reused prefix, the passes' own
+            // additions (markers, schema documents) included.
+            fresh: enriched.slice(merged.reusedKept.length)
+          });
+          await cache.write(cacheInput, enriched, attribution);
         } catch {
         }
       });
@@ -13396,7 +14385,7 @@ function createTypeScriptAdapter(config) {
             packs: config.frameworks,
             tallies,
             filesInProject: tsconfigFileList?.length ?? null,
-            filesWalked: sourceFiles.length,
+            filesWalked: walkList.length,
             summaries: enriched,
             tsConfigFilePath: config.tsConfigFilePath,
             projectRoot: commonDirectoryOf(
@@ -13406,17 +14395,204 @@ function createTypeScriptAdapter(config) {
           })
         );
       }
-      nameSummaries(enriched, {
-        workspace: config.workspace ?? workspaceNameFor(
-          commonDirectoryOf(sourceFiles.map((f) => f.getFilePath()))
-        ),
-        projectRoot: commonDirectoryOf(sourceFiles.map((f) => f.getFilePath()))
-      });
-      return enriched;
+      return named(
+        enriched,
+        config.workspace,
+        runRoot ?? commonDirectoryOf(sourceFiles.map((f) => f.getFilePath()))
+      );
     }
   };
 }
-function synthesizeSubUnits(summaries, project, frameworks, options, tallies) {
+function mountAssumptionsAgree(record, index) {
+  return Object.entries(record.mountPrefixes).every(
+    ([childId, prefix]) => (index.prefixForId?.(childId) ?? "") === prefix
+  );
+}
+function attributeReachedSummaries(seeds, reached, facts, owners) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const [from, to] of facts.db.facts("calls")) {
+    const key = String(from);
+    const bucket = adjacency.get(key) ?? [];
+    bucket.push(String(to));
+    adjacency.set(key, bucket);
+  }
+  const seedKeysByRoot = /* @__PURE__ */ new Map();
+  for (const seed of seeds) {
+    const key = facts.unitKeyBySummary.get(seed);
+    if (key === void 0) {
+      continue;
+    }
+    for (const root of owners.get(seed) ?? []) {
+      const bucket = seedKeysByRoot.get(root) ?? [];
+      bucket.push(key);
+      seedKeysByRoot.set(root, bucket);
+    }
+  }
+  const reachableByRoot = /* @__PURE__ */ new Map();
+  const rootsByKey = /* @__PURE__ */ new Map();
+  for (const [root, seedKeys] of seedKeysByRoot) {
+    const seen = new Set(seedKeys);
+    const queue = [...seedKeys];
+    while (queue.length > 0) {
+      const key = queue.pop();
+      if (key === void 0) {
+        continue;
+      }
+      for (const next of adjacency.get(key) ?? []) {
+        if (!seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
+        }
+      }
+      const keyRoots = rootsByKey.get(key) ?? /* @__PURE__ */ new Set();
+      keyRoots.add(root);
+      rootsByKey.set(key, keyRoots);
+    }
+    reachableByRoot.set(root, seen);
+  }
+  for (const summary of reached) {
+    const key = facts.unitKeyBySummary.get(summary);
+    if (key === void 0) {
+      continue;
+    }
+    const keyRoots = rootsByKey.get(key);
+    if (keyRoots !== void 0 && keyRoots.size > 0) {
+      owners.set(summary, new Set(keyRoots));
+    }
+  }
+  return { reachableByRoot, rootsByKey };
+}
+function fileOfNodeKey(key) {
+  const cut = key.lastIndexOf(":");
+  return cut <= 0 ? null : key.slice(0, cut);
+}
+function summaryMergeKey(summary) {
+  return JSON.stringify([
+    summary.location.file,
+    summary.location.range.start,
+    summary.location.range.end,
+    summary.kind,
+    summary.identity.name,
+    summary.identity.exportPath,
+    summary.identity.boundaryBinding
+  ]);
+}
+function mergeWithReused(reused, fresh, ownersBySummary) {
+  if (reused === null) {
+    return { summaries: fresh, reusedKept: [], reusedOwners: [] };
+  }
+  const freshByKey = /* @__PURE__ */ new Map();
+  for (const summary of fresh) {
+    freshByKey.set(summaryMergeKey(summary), summary);
+  }
+  const reusedKept = [];
+  const reusedOwners = [];
+  reused.summaries.forEach((summary, i) => {
+    const owners = reused.owners[i] ?? [];
+    const supersededBy = freshByKey.get(summaryMergeKey(summary));
+    if (supersededBy !== void 0) {
+      const freshOwners = ownersBySummary.get(supersededBy) ?? /* @__PURE__ */ new Set();
+      for (const owner of owners) {
+        freshOwners.add(owner);
+      }
+      ownersBySummary.set(supersededBy, freshOwners);
+      return;
+    }
+    reusedKept.push(summary);
+    reusedOwners.push(owners);
+  });
+  return { summaries: [...reusedKept, ...fresh], reusedKept, reusedOwners };
+}
+function readsRunLevelJoins(summary) {
+  if ((0, import_behavioral_ir6.readSourceDocumentMetadata)(summary) !== void 0) {
+    return true;
+  }
+  if ((0, import_behavioral_ir6.readGraphqlMetadata)(summary)?.client !== void 0) {
+    return true;
+  }
+  const semantics = summary.identity.boundaryBinding?.semantics;
+  return semantics !== void 0 && "operationType" in semantics;
+}
+function buildCacheAttribution(args) {
+  const references = createReferenceIndex(
+    args.project.getSourceFiles().filter((sf) => !sf.isDeclarationFile())
+  );
+  const packNamesByPath = /* @__PURE__ */ new Map();
+  for (const [sf, packs] of args.packsByFile) {
+    packNamesByPath.set(
+      sf.getFilePath(),
+      packs.map((p) => p.name)
+    );
+  }
+  const summariesByRoot = /* @__PURE__ */ new Map();
+  for (const summary of args.fresh) {
+    for (const root of args.ownersBySummary.get(summary) ?? []) {
+      const bucket = summariesByRoot.get(root) ?? [];
+      bucket.push(summary);
+      summariesByRoot.set(root, bucket);
+    }
+  }
+  const roots = [];
+  for (const [rootPath, sink] of args.sinkByRoot) {
+    const deps = new Set(sink.files);
+    for (const dep of references.directOf(rootPath)) {
+      deps.add(dep);
+    }
+    let cacheable = true;
+    for (const summary of summariesByRoot.get(rootPath) ?? []) {
+      deps.add(summary.location.file);
+      if (readsRunLevelJoins(summary)) {
+        cacheable = false;
+      }
+    }
+    const reachable = args.closureOwnership?.reachableByRoot.get(rootPath) ?? [];
+    for (const key of reachable) {
+      const keyFile = fileOfNodeKey(key);
+      if (keyFile !== null) {
+        deps.add(keyFile);
+        for (const hop of references.directOf(keyFile)) {
+          deps.add(hop);
+        }
+      }
+      for (const filePath of args.filesByKey?.get(key) ?? []) {
+        deps.add(filePath);
+      }
+    }
+    deps.delete(rootPath);
+    roots.push({
+      path: rootPath,
+      cacheable,
+      deps: [...deps].sort(),
+      claims: sink.claims,
+      mountPrefixes: Object.fromEntries(sink.mountPrefixes),
+      packs: packNamesByPath.get(rootPath) ?? []
+    });
+  }
+  if (args.plan !== null) {
+    for (const rootPath of args.validRoots) {
+      const record = args.plan.roots.get(rootPath);
+      if (record !== void 0) {
+        roots.push(record);
+      }
+    }
+  }
+  const reusedOwners = args.reusedKept.map((summary, i) => {
+    const combined = new Set(args.reusedOwners[i] ?? []);
+    const key = args.unitKeyBySummary.get(summary);
+    if (key !== void 0) {
+      for (const root of args.closureOwnership?.rootsByKey.get(key) ?? []) {
+        combined.add(root);
+      }
+    }
+    return [...combined];
+  });
+  const owners = [
+    ...reusedOwners,
+    ...args.fresh.map((s) => [...args.ownersBySummary.get(s) ?? []])
+  ];
+  return { roots, owners };
+}
+function synthesizeSubUnits(summaries, project, frameworks, options, tallies, onCreated) {
   const packByRecognition = /* @__PURE__ */ new Map();
   for (const pack of frameworks) {
     packByRecognition.set(pack.name, pack);
@@ -13459,6 +14635,7 @@ function synthesizeSubUnits(summaries, project, frameworks, options, tallies) {
       );
       if (summary !== null) {
         synthesized.push(summary);
+        onCreated?.(summary, parent);
       }
     }
   }
@@ -13467,14 +14644,7 @@ function synthesizeSubUnits(summaries, project, frameworks, options, tallies) {
 var DEFAULT_SUB_UNIT_TERMINALS = [
   { kind: "return", match: { type: "returnStatement" }, extraction: {} },
   { kind: "throw", match: { type: "throwExpression" }, extraction: {} },
-  // A callback routinely falls off the end returning `undefined`, so
-  // fall-through gives it a default transition. HTTP packs do not opt in:
-  // a handler that sends no response should come out with none.
-  {
-    kind: "return",
-    match: { type: "functionFallthrough" },
-    extraction: {}
-  }
+  FUNCTION_FALLTHROUGH_TERMINAL
 ];
 var DEFAULT_SUB_UNIT_INPUT_MAPPING = {
   type: "positionalParams",
@@ -13659,7 +14829,7 @@ function readStringArg(arg) {
   }
   return candidate.value;
 }
-function rootIdentifier(node) {
+function rootIdentifier2(node) {
   let current2 = node;
   while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
     current2 = current2.getExpression();
@@ -13667,10 +14837,165 @@ function rootIdentifier(node) {
   return import_ts_morph58.Node.isIdentifier(current2) ? current2 : null;
 }
 
+// src/facts/why.ts
+var import_node_path11 = __toESM(require("path"), 1);
+var import_ts_morph59 = require("ts-morph");
+var import_resolution2 = require("@suss/resolution");
+var JS_PHRASES = {
+  bind: ({ tuple, describe }) => ({
+    reason: `${describe(tuple[0])} is a .bind of ${describe(tuple[1])}, which runs the same function`
+  })
+};
+var WhySession = class {
+  project;
+  store;
+  root;
+  constructor(options) {
+    this.root = import_node_path11.default.resolve(options.dir);
+    const tsconfig = findNearestTsconfig(this.root);
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph59.Project({ tsConfigFilePath: tsconfig });
+    this.store = new ResolutionStore();
+  }
+  /**
+   * The smallest expression on `line` of `file` whose text is exactly
+   * `text`, or null. Spelled from the person's side: the name as
+   * written, not a node id.
+   */
+  findExpression(file, line, text) {
+    const sourceFile = this.sourceFileAt(file);
+    if (sourceFile === null) {
+      return null;
+    }
+    let found = null;
+    sourceFile.forEachDescendant((node) => {
+      if (import_ts_morph59.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+        found = node;
+      }
+    });
+    return found;
+  }
+  /**
+   * The callee of the call written as `calleeText` between `startLine`
+   * and `endLine` of `file`, or null. This is how a summary's recorded
+   * callee gets back to its node: the summary keeps source text and a
+   * range, not ids.
+   */
+  findCallee(file, startLine, endLine, calleeText) {
+    const sourceFile = this.sourceFileAt(file);
+    if (sourceFile === null) {
+      return null;
+    }
+    for (const call of sourceFile.getDescendantsOfKind(
+      import_ts_morph59.SyntaxKind.CallExpression
+    )) {
+      const line = call.getStartLineNumber();
+      if (line < startLine || line > endLine) {
+        continue;
+      }
+      if (call.getExpression().getText() === calleeText) {
+        return call.getExpression();
+      }
+    }
+    return null;
+  }
+  /**
+   * Why `value` resolves to what it does: the witness proof, flattened
+   * to the chain and rendered. Null when the value does not resolve,
+   * which the caller says in its own words.
+   */
+  explain(value, options = {}) {
+    const explained = this.store.explainCallable(value, options);
+    if (explained === null) {
+      return null;
+    }
+    const describe = (atom) => {
+      const node = explained.nodeFor(atom);
+      if (node === void 0) {
+        return this.displayPath(String(atom));
+      }
+      const at = this.locate(node);
+      return `${at.name} (${at.file}:${at.line})`;
+    };
+    const explanation = (0, import_resolution2.explainResolutionProof)(explained.proof, {
+      describe,
+      phrases: JS_PHRASES
+    });
+    if (explanation === null) {
+      return null;
+    }
+    return {
+      explanation,
+      chain: explanation.atoms.map((atom) => describe(atom)),
+      lines: (0, import_resolution2.renderExplanation)(explanation, describe),
+      target: this.locate(explained.target),
+      stats: explained.stats
+    };
+  }
+  /** Where a found node is, in the terms an answer prints. */
+  locate(node) {
+    return {
+      name: displayNameOf(node),
+      file: this.displayPath(node.getSourceFile().getFilePath()),
+      line: node.getStartLineNumber()
+    };
+  }
+  sourceFileAt(file) {
+    const absolute = import_node_path11.default.resolve(this.root, file);
+    const loaded = this.project.getSourceFile(absolute);
+    if (loaded !== void 0) {
+      return loaded;
+    }
+    try {
+      return this.project.addSourceFileAtPath(absolute);
+    } catch {
+      return null;
+    }
+  }
+  /** A module key: a file path said relative to the root, or a package name. */
+  displayPath(key) {
+    if (key.startsWith(this.root)) {
+      return import_node_path11.default.relative(this.root, key);
+    }
+    return key;
+  }
+};
+function displayNameOf(node) {
+  if (import_ts_morph59.Node.isIdentifier(node) || import_ts_morph59.Node.isPropertyAccessExpression(node)) {
+    return node.getText();
+  }
+  if (import_ts_morph59.Node.isCallExpression(node) || import_ts_morph59.Node.isNewExpression(node)) {
+    return `${node.getExpression()?.getText() ?? "call"}(...)`;
+  }
+  if (import_ts_morph59.Node.isFunctionDeclaration(node) || import_ts_morph59.Node.isClassDeclaration(node) || import_ts_morph59.Node.isMethodDeclaration(node) || import_ts_morph59.Node.isVariableDeclaration(node)) {
+    const name = node.getName();
+    if (name !== void 0) {
+      return name;
+    }
+  }
+  if (import_ts_morph59.Node.isArrowFunction(node) || import_ts_morph59.Node.isFunctionExpression(node)) {
+    const parent = node.getParent();
+    if (parent !== void 0 && import_ts_morph59.Node.isVariableDeclaration(parent)) {
+      return parent.getName();
+    }
+  }
+  const text = node.getText().split("\n")[0].trim();
+  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: {
+        name: "unit bodies to look inside",
+        count: funnel.unitsInGatedFiles
+      },
+      to: { name: "effects recognized", count: funnel.effectsRecognized },
+      meaning: "its import gate found the library and it matched nothing in the bodies it saw"
+    });
+  }
   if (funnel.discovers && gateSaysSomething) {
     stages.push({
       from: { name: "candidate files", count: funnel.candidateFiles },
@@ -13780,7 +15105,8 @@ function formatPackHealth(checks, audiences) {
 }
 
 // src/resolve/readName.ts
-var import_ts_morph59 = require("ts-morph");
+var import_ts_morph60 = require("ts-morph");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -13794,6 +15120,14 @@ function readName(expr, options = {}) {
   if (name !== null || options.unsettled !== "reference") {
     return name;
   }
+  const reference = referenceIn(expr);
+  return reference === null ? null : (0, import_behavioral_ir7.referenceName)(reference);
+}
+function referenceIn(expr) {
+  const fromParameter = parameterPath(expr);
+  if (fromParameter !== null) {
+    return fromParameter;
+  }
   const asked = holeName(expr, {
     resolve: () => null,
     bindings: /* @__PURE__ */ new Map(),
@@ -13801,7 +15135,25 @@ function readName(expr, options = {}) {
     seen: /* @__PURE__ */ new Set(),
     insideHole: true
   });
-  return asked === UNNAMED_HOLE ? null : `{${asked}}`;
+  return asked === UNNAMED_HOLE ? null : { root: asked, fields: [] };
+}
+function parameterPath(expr) {
+  const fields = [];
+  let step = expr;
+  while (import_ts_morph60.Node.isPropertyAccessExpression(step)) {
+    fields.unshift(step.getName());
+    step = step.getExpression();
+  }
+  if (!import_ts_morph60.Node.isIdentifier(step) || !isParameter(step)) {
+    return null;
+  }
+  return { root: step.getText(), fields };
+}
+function isParameter(identifier) {
+  const declarations = identifier.getSymbol()?.getDeclarations() ?? [];
+  return declarations.some(
+    (declaration) => import_ts_morph60.Node.isParameterDeclaration(declaration)
+  );
 }
 function read(expr, ctx) {
   if (ctx.seen.has(expr)) {
@@ -13809,35 +15161,52 @@ function read(expr, ctx) {
   }
   const seen = new Set(ctx.seen).add(expr);
   const inner = { ...ctx, seen };
-  if (import_ts_morph59.Node.isStringLiteral(expr) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph60.Node.isStringLiteral(expr) || import_ts_morph60.Node.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.getLiteralValue();
   }
-  if (import_ts_morph59.Node.isNumericLiteral(expr)) {
+  if (import_ts_morph60.Node.isNumericLiteral(expr)) {
     return expr.getLiteralText();
   }
-  if (import_ts_morph59.Node.isTemplateExpression(expr)) {
+  if (import_ts_morph60.Node.isTemplateExpression(expr)) {
     return fromTemplate(expr, inner);
   }
-  if (import_ts_morph59.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph60.Node.isParenthesizedExpression(expr)) {
     return read(expr.getExpression(), inner);
   }
-  if (import_ts_morph59.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph60.Node.isBinaryExpression(expr)) {
     return fromBinary(expr, inner);
   }
-  if (import_ts_morph59.Node.isCallExpression(expr)) {
+  if (import_ts_morph60.Node.isCallExpression(expr)) {
     return fromCall(expr, inner);
   }
-  if (import_ts_morph59.Node.isIdentifier(expr)) {
+  if (import_ts_morph60.Node.isIdentifier(expr)) {
     const only = boundOnce(expr, ctx);
     if (only !== null) {
       return read(only.node, { ...inner, bindings: only.scope });
     }
   }
   const written = ctx.resolve(expr);
-  return written === null || written === expr ? null : read(written, inner);
+  if (written === null || written === expr) {
+    return null;
+  }
+  if (ctx.insideHole && isFallbackBranch(written)) {
+    return null;
+  }
+  return read(written, inner);
+}
+function isFallbackBranch(node) {
+  let step = node.getParent();
+  while (step !== void 0 && import_ts_morph60.Node.isParenthesizedExpression(step)) {
+    step = step.getParent();
+  }
+  if (step === void 0 || !import_ts_morph60.Node.isBinaryExpression(step)) {
+    return false;
+  }
+  const operator = step.getOperatorToken().getKind();
+  return operator === import_ts_morph60.SyntaxKind.BarBarToken || operator === import_ts_morph60.SyntaxKind.QuestionQuestionToken;
 }
 function fromTemplate(expr, ctx) {
-  if (!import_ts_morph59.Node.isTemplateExpression(expr)) {
+  if (!import_ts_morph60.Node.isTemplateExpression(expr)) {
     return null;
   }
   let name = expr.getHead().getLiteralText();
@@ -13848,28 +15217,28 @@ function fromTemplate(expr, ctx) {
   return name;
 }
 function fromBinary(expr, ctx) {
-  if (!import_ts_morph59.Node.isBinaryExpression(expr)) {
+  if (!import_ts_morph60.Node.isBinaryExpression(expr)) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === import_ts_morph59.SyntaxKind.BarBarToken || operator === import_ts_morph59.SyntaxKind.QuestionQuestionToken) {
+  if (operator === import_ts_morph60.SyntaxKind.BarBarToken || operator === import_ts_morph60.SyntaxKind.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== import_ts_morph59.SyntaxKind.PlusToken) {
+  if (operator !== import_ts_morph60.SyntaxKind.PlusToken) {
     return null;
   }
   const parts = { ...ctx, insideHole: true };
   return readOrHole(expr.getLeft(), parts) + readOrHole(expr.getRight(), parts);
 }
 function fromCall(expr, ctx) {
-  if (!import_ts_morph59.Node.isCallExpression(expr)) {
+  if (!import_ts_morph60.Node.isCallExpression(expr)) {
     return null;
   }
   const callee = expr.getExpression();
-  if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
+  if (import_ts_morph60.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
     return fromJoin(callee.getExpression(), expr.getArguments(), ctx);
   }
-  if (import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === "String") {
+  if (import_ts_morph60.Node.isIdentifier(callee) && callee.getText() === "String") {
     const only = expr.getArguments()[0];
     return only === void 0 ? null : readOrHole(only, ctx);
   }
@@ -13888,7 +15257,7 @@ function fromCall(expr, ctx) {
 }
 function fromJoin(subject, args, ctx) {
   const separator = args[0];
-  if (separator === void 0 || !import_ts_morph59.Node.isStringLiteral(separator)) {
+  if (separator === void 0 || !import_ts_morph60.Node.isStringLiteral(separator)) {
     return null;
   }
   const parts = elementsOf(subject, ctx);
@@ -13904,17 +15273,17 @@ function fromJoin(subject, args, ctx) {
   ).join(separator.getLiteralValue());
 }
 function elementsOf(subject, ctx) {
-  if (import_ts_morph59.Node.isArrayLiteralExpression(subject)) {
+  if (import_ts_morph60.Node.isArrayLiteralExpression(subject)) {
     return subject.getElements().map((element) => here(element, ctx));
   }
-  if (import_ts_morph59.Node.isCallExpression(subject)) {
+  if (import_ts_morph60.Node.isCallExpression(subject)) {
     const callee = subject.getExpression();
-    if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
+    if (import_ts_morph60.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
       return elementsOf(callee.getExpression(), ctx);
     }
     return null;
   }
-  if (!import_ts_morph59.Node.isIdentifier(subject)) {
+  if (!import_ts_morph60.Node.isIdentifier(subject)) {
     return null;
   }
   const bound = ctx.bindings.get(subject.getText());
@@ -13922,7 +15291,7 @@ function elementsOf(subject, ctx) {
     return null;
   }
   const only = bound.length === 1 ? bound[0] : void 0;
-  return only !== void 0 && import_ts_morph59.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
+  return only !== void 0 && import_ts_morph60.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
 }
 function singleReturnBody(callee, ctx) {
   const declaration = declarationOf2(callee, ctx);
@@ -13937,22 +15306,22 @@ function singleReturnBody(callee, ctx) {
   if (body === void 0) {
     return null;
   }
-  if (import_ts_morph59.Node.isExpression(body)) {
+  if (import_ts_morph60.Node.isExpression(body)) {
     return { parameters, returned: body };
   }
-  if (!import_ts_morph59.Node.isBlock(body)) {
+  if (!import_ts_morph60.Node.isBlock(body)) {
     return null;
   }
   const statements = body.getStatements();
   const only = statements[0];
-  if (statements.length !== 1 || only === void 0 || !import_ts_morph59.Node.isReturnStatement(only)) {
+  if (statements.length !== 1 || only === void 0 || !import_ts_morph60.Node.isReturnStatement(only)) {
     return null;
   }
   const returned = only.getExpression();
   return returned === void 0 ? null : { parameters, returned };
 }
 function declarationOf2(callee, ctx) {
-  const symbol = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
+  const symbol = import_ts_morph60.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
   const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
   for (const declaration of declarations) {
     const callable = asCallable(declaration);
@@ -13964,14 +15333,14 @@ function declarationOf2(callee, ctx) {
   return written === null || written === callee ? null : declarationOf2(written, { ...ctx, resolve: () => null });
 }
 function asCallable(declaration) {
-  if (import_ts_morph59.Node.isFunctionDeclaration(declaration) || import_ts_morph59.Node.isMethodDeclaration(declaration) || import_ts_morph59.Node.isArrowFunction(declaration) || import_ts_morph59.Node.isFunctionExpression(declaration)) {
+  if (import_ts_morph60.Node.isFunctionDeclaration(declaration) || import_ts_morph60.Node.isMethodDeclaration(declaration) || import_ts_morph60.Node.isArrowFunction(declaration) || import_ts_morph60.Node.isFunctionExpression(declaration)) {
     return declaration;
   }
-  if (!import_ts_morph59.Node.isVariableDeclaration(declaration)) {
+  if (!import_ts_morph60.Node.isVariableDeclaration(declaration)) {
     return null;
   }
   const initializer = declaration.getInitializer();
-  if (initializer !== void 0 && (import_ts_morph59.Node.isArrowFunction(initializer) || import_ts_morph59.Node.isFunctionExpression(initializer))) {
+  if (initializer !== void 0 && (import_ts_morph60.Node.isArrowFunction(initializer) || import_ts_morph60.Node.isFunctionExpression(initializer))) {
     return initializer;
   }
   return null;
@@ -13993,22 +15362,22 @@ function here(node, ctx) {
   return { node, scope: ctx.bindings };
 }
 function boundOnce(expr, ctx) {
-  const bound = import_ts_morph59.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
+  const bound = import_ts_morph60.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
   return bound !== void 0 && bound.length === 1 ? bound[0] : null;
 }
 function readOrHole(expr, ctx) {
   const name = read(expr, ctx);
-  return name ?? `{${holeName(expr, ctx)}}`;
+  return name ?? (0, import_behavioral_ir7.patternHole)(holeName(expr, ctx));
 }
 function holeName(expr, ctx) {
   const bound = boundOnce(expr, ctx);
   if (bound !== null) {
     return holeName(bound.node, { ...ctx, bindings: bound.scope });
   }
-  if (import_ts_morph59.Node.isIdentifier(expr)) {
+  if (import_ts_morph60.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph59.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph60.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return UNNAMED_HOLE;
@@ -14017,6 +15386,7 @@ function holeName(expr, ctx) {
 0 && (module.exports = {
   ADAPTER_VERSION,
   ResolutionStore,
+  WhySession,
   collectAncestorBranches,
   collectClientFieldAccesses,
   computeAdapterPacksDigest,
@@ -14042,5 +15412,6 @@ function holeName(expr, ctx) {
   readName,
   resolveAliasedSymbol,
   resolveSubject,
-  rootIdentifier
+  rootIdentifier,
+  workspaceRootFor
 });