@suss/adapter-typescript 0.8.0 → 0.10.0

package/dist/index.cjs

@@ -63,7 +63,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path9 = __toESM(require("path"), 1);
-var import_ts_morph55 = require("ts-morph");
+var import_ts_morph56 = require("ts-morph");
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor5 = require("@suss/extractor");
@@ -1076,24 +1076,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 +1150,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 +1172,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 +1270,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 +1308,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 +1316,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 +1333,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 +1341,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 +1398,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 +1407,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 +1509,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");
@@ -1828,10 +1932,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 +1959,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 +2025,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 +2044,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 +2070,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 +2088,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 +2127,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 +2142,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;
@@ -2128,7 +2264,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 +2340,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)) {
@@ -4940,7 +5044,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 +5057,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 : [[]]
@@ -5083,7 +5192,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 +5204,7 @@ function createCacheLayer(cacheDir) {
         kind: "miss",
         diagnostic: { kind: "miss", missReason: "no-manifest" }
       }),
+      plan: async () => null,
       write: async () => {
       }
     };
@@ -5122,20 +5232,36 @@ function createCacheLayer(cacheDir) {
       return {
         kind: "hit",
         summaries: manifest.summaries,
+        ...manifest.projectRoot === void 0 ? {} : { projectRoot: manifest.projectRoot },
         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 +5271,171 @@ 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,
+    storedProjectRoot: manifest.projectRoot ?? null,
+    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];
+          })
+        ),
+        ...manifest.projectRoot === void 0 ? {} : { projectRoot: manifest.projectRoot }
+      };
+    }
+  };
+}
+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,
+    ...attribution.projectRoot === void 0 ? {} : { projectRoot: attribution.projectRoot }
+  };
+}
+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 +5449,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}`);
 }
@@ -7010,7 +7301,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)) {
@@ -9568,7 +9859,10 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
           resolverInfo: {
             typeName,
             fieldName,
-            ...schemaSdl !== null ? { schemaSdl } : {}
+            ...schemaSdl !== null ? {
+              schemaSdl,
+              schemaDocument: config.getSourceFile().getFilePath()
+            } : {}
           }
         });
       }
@@ -9765,7 +10059,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 +10124,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) {
@@ -10066,11 +10373,12 @@ var import_ts_morph50 = require("ts-morph");
 var import_datalog2 = require("@suss/datalog");
 var import_resolution = require("@suss/resolution");
 var JS_RULES = [
-  // f.bind(...) resolves to whatever f resolves to.
+  // f.bind(...) leads wherever f leads. Stated as a step, so the
+  // questions other than `comesTo` follow it too.
   (0, import_datalog2.rule)(
-    "comesTo",
-    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("h")],
-    [(0, import_datalog2.lit)("bindCall", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("t")), (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("t"), (0, import_datalog2.variable)("h"))]
+    "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"))]
   )
 ];
 var RESOLUTION_PROGRAM = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? {
@@ -10088,6 +10396,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;
@@ -10148,7 +10458,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(
@@ -10156,7 +10469,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;
   }
   /**
@@ -10190,6 +10506,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 = [];
@@ -10198,6 +10515,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));
       }
@@ -10494,6 +10813,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 = [
@@ -10539,7 +10879,10 @@ function bindingLabel(binding) {
   if (semantics.name === "graphql-operation") {
     return `${semantics.operationType} ${semantics.operationName ?? ""}`.trim();
   }
-  return semantics.exportName ?? semantics.module ?? binding.recognition;
+  if ("exportName" in semantics || "module" in semantics) {
+    return semantics.exportName ?? semantics.module ?? binding.recognition;
+  }
+  return binding.recognition;
 }
 function effectFact(effect) {
   if (effect.type === "invocation") {
@@ -10611,10 +10954,105 @@ function deriveBoundaryEffects(summaries, facts) {
 }
 
 // src/resolve/reachableClosure.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
+
+// src/resolve/unfollowedCall.ts
+var import_ts_morph51 = require("ts-morph");
+function isInExternalCode(sourceFile) {
+  if (sourceFile.isDeclarationFile()) {
+    return true;
+  }
+  return sourceFile.getFilePath().includes("/node_modules/");
+}
+function hasBody(fn) {
+  if (import_ts_morph51.Node.isFunctionDeclaration(fn) || import_ts_morph51.Node.isMethodDeclaration(fn) || import_ts_morph51.Node.isFunctionExpression(fn)) {
+    return fn.getBody?.() !== void 0;
+  }
+  return true;
+}
+function isDeclaredShape(declaration) {
+  return (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+}
+function isExternalDeclaration(declaration) {
+  if (isInExternalCode(declaration.getSourceFile())) {
+    return true;
+  }
+  if (import_ts_morph51.Node.isImportSpecifier(declaration) || import_ts_morph51.Node.isImportClause(declaration) || import_ts_morph51.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph51.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    return target === void 0 || isInExternalCode(target);
+  }
+  return declaresAnotherModule(declaration);
+}
+function declaresAnotherModule(declaration) {
+  const module2 = declaration.getFirstAncestorByKind(
+    import_ts_morph51.SyntaxKind.ModuleDeclaration
+  );
+  return module2 !== void 0 && import_ts_morph51.Node.isStringLiteral(module2.getNameNode());
+}
+function statesShapeOnly(declaration) {
+  if (isExternalDeclaration(declaration)) {
+    return false;
+  }
+  if (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) {
+    return true;
+  }
+  if (import_ts_morph51.Node.isFunctionDeclaration(declaration) || import_ts_morph51.Node.isMethodDeclaration(declaration)) {
+    return declaration.getBody() === void 0;
+  }
+  return false;
+}
+function declarationsBehind(symbol) {
+  if (symbol === void 0) {
+    return [];
+  }
+  const behind = symbol.getAliasedSymbol()?.getDeclarations() ?? [];
+  return behind.length > 0 ? behind : symbol.getDeclarations();
+}
+function 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";
+  }
+  if (declarations.some(statesShapeOnly)) {
+    return "noBody";
+  }
+  return "unsettledValue";
+}
+var RECORDED = {
+  noBody: true,
+  unsettledValue: true,
+  outsideRun: false,
+  noDeclaration: false
+};
+function worthRecording(reason) {
+  return RECORDED[reason];
+}
+var STOP_SENTENCE = {
+  noBody: (callee) => `The call to ${callee} lands on a declaration with no body, so whatever runs there is missing from this summary`,
+  unsettledValue: (callee) => `The call to ${callee} goes through a value this run could not settle, so whatever runs there is missing from this summary`,
+  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`
+};
+function unfollowedCallGap(stop) {
+  return {
+    type: "unfollowedCall",
+    conditions: [],
+    consequence: "unknown",
+    description: STOP_SENTENCE[stop.reason](stop.callee)
+  };
+}
+
+// src/resolve/reachableClosure.ts
 var reachablePack = {
   name: "reachable",
   languages: ["typescript"],
@@ -10637,23 +11075,6 @@ function nodeKey2(func) {
   const sf = func.getSourceFile();
   return `${sf.getFilePath()}:${func.getStart()}-${func.getEnd()}`;
 }
-function isInExternalCode(sourceFile) {
-  if (sourceFile.isDeclarationFile()) {
-    return true;
-  }
-  const filePath = sourceFile.getFilePath();
-  if (filePath.includes("/node_modules/")) {
-    return true;
-  }
-  return false;
-}
-function hasBody(fn) {
-  if (import_ts_morph51.Node.isFunctionDeclaration(fn) || import_ts_morph51.Node.isMethodDeclaration(fn) || import_ts_morph51.Node.isFunctionExpression(fn)) {
-    const body = fn.getBody?.();
-    return body !== void 0;
-  }
-  return true;
-}
 function resolveDecl(decl, calleeName) {
   if (isInExternalCode(decl.getSourceFile())) {
     return null;
@@ -10665,14 +11086,14 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph51.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph52.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph51.Node.isArrowFunction(init) || import_ts_morph51.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph52.Node.isArrowFunction(init) || import_ts_morph52.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
   }
-  if (import_ts_morph51.Node.isImportSpecifier(decl)) {
+  if (import_ts_morph52.Node.isImportSpecifier(decl)) {
     const importDecl = decl.getImportDeclaration();
     const sf = importDecl.getModuleSpecifierSourceFile();
     if (sf === void 0 || isInExternalCode(sf)) {
@@ -10693,78 +11114,85 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph51.Node.isFunctionDeclaration(decl) || import_ts_morph51.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph52.Node.isFunctionDeclaration(decl) || import_ts_morph52.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph51.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph52.Node.isFunctionExpression(decl)) {
     const n = decl.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
   const parent = decl.getParent();
-  if (parent !== void 0 && import_ts_morph51.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph52.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph51.Node.isCallExpression(call)) {
+  if (!import_ts_morph52.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
-  const declarations = callee.getSymbol()?.getDeclarations() ?? [];
+  const symbol = callee.getSymbol();
+  const declarations = symbol?.getDeclarations() ?? [];
   for (const decl of declarations) {
     const resolved = resolveDecl(decl, calleeName);
     if (resolved !== null) {
-      return resolved;
+      return { kind: "followed", candidate: resolved };
     }
   }
-  if (scan.resolveCallable === void 0 || !readsAField(callee)) {
-    return null;
-  }
-  if (!declarations.some(isDeclaredShape)) {
-    return null;
-  }
-  const value = scan.resolveCallable(callee, scan.reachedFrom);
-  return value === null ? null : resolveDecl(value, calleeName);
-}
-function readsAField(callee) {
-  if (!import_ts_morph51.Node.isPropertyAccessExpression(callee)) {
-    return false;
-  }
-  let receiver = callee.getExpression();
-  while (import_ts_morph51.Node.isPropertyAccessExpression(receiver)) {
-    receiver = receiver.getExpression();
+  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);
+    if (resolved !== null) {
+      return { kind: "followed", candidate: resolved };
+    }
   }
-  return import_ts_morph51.Node.isThisExpression(receiver);
-}
-function isDeclaredShape(declaration) {
-  return (import_ts_morph51.Node.isMethodSignature(declaration) || import_ts_morph51.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+  return {
+    kind: "stopped",
+    stop: {
+      callee: calleeName,
+      reason: classifyStop(declarationsBehind(symbol))
+    }
+  };
 }
 function collectReachable(func, scan) {
-  const found = [];
+  const candidates = [];
+  const stops = [];
   const seen = /* @__PURE__ */ new Set();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph51.Node.isCallExpression(node)) {
+    if (!import_ts_morph52.Node.isCallExpression(node)) {
       return;
     }
-    const calleeText = node.getExpression().getText();
-    const resolved = resolveCallee(node, calleeText, scan);
-    if (resolved === null) {
+    const calleeText = normalizeCallee(node.getExpression().getText());
+    const outcome = resolveCallee(node, calleeText, scan);
+    if (outcome === null) {
+      return;
+    }
+    if (outcome.kind === "stopped") {
+      const stopKey = `${outcome.stop.reason}:${outcome.stop.callee}`;
+      if (!seen.has(stopKey) && worthRecording(outcome.stop.reason)) {
+        seen.add(stopKey);
+        stops.push(outcome.stop);
+      }
       return;
     }
-    const key = nodeKey2(resolved.func);
+    const key = nodeKey2(outcome.candidate.func);
     if (seen.has(key)) {
       return;
     }
     seen.add(key);
-    found.push(resolved);
+    candidates.push(outcome.candidate);
   });
-  return found;
+  return { candidates, stops };
+}
+function normalizeCallee(text) {
+  return text.replace(/\s+/g, " ").trim();
 }
 function extractReachableSummary(candidate, options, recognizers) {
   const unit = {
@@ -10798,12 +11226,14 @@ 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();
   const seedKeys = /* @__PURE__ */ new Set();
   const scanned = /* @__PURE__ */ new Set();
+  const stopsByKey = /* @__PURE__ */ new Map();
+  const summariesByKey = /* @__PURE__ */ new Map();
   const reachedFrom = /* @__PURE__ */ new Map();
   for (const seed of seeds) {
     const func = lookup.functionAt(seed.location);
@@ -10812,9 +11242,19 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       seedKeys.add(key);
       functionByKey.set(key, { func, name: seed.identity.name });
       facts?.unitKeyBySummary.set(seed, key);
+      rememberSummary(summariesByKey, key, seed);
       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));
@@ -10832,7 +11272,15 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
         ...recognizers.resolveCallable === void 0 ? {} : { resolveCallable: recognizers.resolveCallable },
         ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
       };
-      for (const candidate of collectReachable(source.func, scan)) {
+      const { candidates, stops } = scanWithRecording(
+        key,
+        facts,
+        () => collectReachable(source.func, scan)
+      );
+      if (stops.length > 0) {
+        stopsByKey.set(key, stops);
+      }
+      for (const candidate of candidates) {
         const calleeKey = nodeKey2(candidate.func);
         if (!functionByKey.has(calleeKey)) {
           functionByKey.set(calleeKey, candidate);
@@ -10847,7 +11295,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);
@@ -10861,15 +11309,50 @@ 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);
   }
+  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);
+  summariesByKey.set(key, bucket);
+}
+function recordStops(stopsByKey, summariesByKey, options) {
+  if (options?.gapHandling === "silent") {
+    return;
+  }
+  for (const [key, stops] of stopsByKey) {
+    for (const summary of summariesByKey.get(key) ?? []) {
+      summary.gaps.push(...stops.map(unfollowedCallGap));
+    }
+  }
+}
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 var import_datalog5 = require("@suss/datalog");
 var RETHROW_RULES = [
   (0, import_datalog5.rule)(
@@ -11009,7 +11492,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph52.Node.isThrowStatement(node)) {
+    if (!import_ts_morph53.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -11019,7 +11502,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph52.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph53.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -11029,13 +11512,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph52.Node.isCatchClause(current2)) {
+    if (import_ts_morph53.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph52.Node.isTryStatement(current2)) {
+    if (import_ts_morph53.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph52.Node.isFunctionDeclaration(current2) || import_ts_morph52.Node.isFunctionExpression(current2) || import_ts_morph52.Node.isArrowFunction(current2) || import_ts_morph52.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph53.Node.isFunctionDeclaration(current2) || import_ts_morph53.Node.isFunctionExpression(current2) || import_ts_morph53.Node.isArrowFunction(current2) || import_ts_morph53.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -11043,14 +11526,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph52.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph53.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph52.Node.isCallExpression(node)) {
+    if (!import_ts_morph53.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -11067,7 +11550,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph52.Node.isCallExpression(call)) {
+  if (!import_ts_morph53.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -11093,12 +11576,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph52.Node.isFunctionDeclaration(decl) || import_ts_morph52.Node.isFunctionExpression(decl) || import_ts_morph52.Node.isArrowFunction(decl) || import_ts_morph52.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph53.Node.isFunctionDeclaration(decl) || import_ts_morph53.Node.isFunctionExpression(decl) || import_ts_morph53.Node.isArrowFunction(decl) || import_ts_morph53.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph52.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph53.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph52.Node.isArrowFunction(init) || import_ts_morph52.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph53.Node.isArrowFunction(init) || import_ts_morph53.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -11106,22 +11589,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph53.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph54.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph53.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph54.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph53.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph54.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph53.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph54.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -11142,11 +11625,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph53.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph54.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph53.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph54.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -11178,7 +11661,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph53.Node.isCallExpression(node)) {
+  if (import_ts_morph54.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -11210,14 +11693,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph53.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph54.Node.isParameterDeclaration(decl)) {
     return null;
   }
   const base = prefixOfThenParam(decl, responseCall, depth + 1);
   return base === null ? null : [...base, ...chain.segments];
 }
 function firstCallbackParamName(callback) {
-  if (callback === void 0 || !(import_ts_morph53.Node.isArrowFunction(callback) || import_ts_morph53.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph54.Node.isArrowFunction(callback) || import_ts_morph54.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -11225,11 +11708,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph53.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph54.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap2(expr) {
   let node = expr;
-  while (import_ts_morph53.Node.isAwaitExpression(node) || import_ts_morph53.Node.isParenthesizedExpression(node) || import_ts_morph53.Node.isAsExpression(node)) {
+  while (import_ts_morph54.Node.isAwaitExpression(node) || import_ts_morph54.Node.isParenthesizedExpression(node) || import_ts_morph54.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -11239,15 +11722,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph53.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph54.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph53.Node.isExpression(expr) ? unwrap2(expr) : expr;
-  if (import_ts_morph53.Node.isCallExpression(node)) {
+  let node = import_ts_morph54.Node.isExpression(expr) ? unwrap2(expr) : expr;
+  if (import_ts_morph54.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph53.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph54.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -11266,16 +11749,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph53.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph54.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph53.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph54.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph53.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph54.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -11286,7 +11769,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph53.Node.isIdentifier(node)) {
+    if (!import_ts_morph54.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -11298,13 +11781,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph53.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph54.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph53.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph54.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -11318,15 +11801,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph53.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph54.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph53.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph54.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph53.Node.isFunctionLikeDeclaration(current2) || import_ts_morph53.Node.isVariableStatement(current2)) {
+    if (import_ts_morph54.Node.isFunctionLikeDeclaration(current2) || import_ts_morph54.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -11389,7 +11872,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph53.Node.isIfStatement(parent)) {
+    if (import_ts_morph54.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -11451,7 +11934,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -11464,7 +11947,7 @@ function createTsSubUnitContext() {
 }
 function skipNestedFunctions(parent) {
   return (node, traversal) => {
-    if (node !== parent && (import_ts_morph54.Node.isFunctionDeclaration(node) || import_ts_morph54.Node.isFunctionExpression(node) || import_ts_morph54.Node.isArrowFunction(node) || import_ts_morph54.Node.isMethodDeclaration(node))) {
+    if (node !== parent && (import_ts_morph55.Node.isFunctionDeclaration(node) || import_ts_morph55.Node.isFunctionExpression(node) || import_ts_morph55.Node.isArrowFunction(node) || import_ts_morph55.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return true;
     }
@@ -11478,18 +11961,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph54.Node.isJsxOpeningElement(node) && !import_ts_morph54.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph55.Node.isJsxOpeningElement(node) && !import_ts_morph55.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph54.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph55.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph54.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph55.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -11512,11 +11995,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph54.Node.isCallExpression(node)) {
+    if (!import_ts_morph55.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph54.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph55.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -11527,10 +12010,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrowFunction(expr) || import_ts_morph54.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph55.Node.isArrowFunction(expr) || import_ts_morph55.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph54.Node.isIdentifier(expr)) {
+  if (import_ts_morph55.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -11549,15 +12032,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph54.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph55.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph54.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph55.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph54.Node.isArrowFunction(init) || import_ts_morph54.Node.isFunctionExpression(init)) {
+    if (import_ts_morph55.Node.isArrowFunction(init) || import_ts_morph55.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -11578,7 +12061,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrowFunction(arg) || import_ts_morph54.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph55.Node.isArrowFunction(arg) || import_ts_morph55.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -11590,7 +12073,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph54.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph55.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -11813,13 +12296,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph55.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph56.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph55.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph56.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph55.Node.isOmittedExpression(element)) {
+      if (import_ts_morph56.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -11830,7 +12313,7 @@ function bindingPatternNames(nameNode) {
 }
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph55.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph56.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -11956,11 +12439,11 @@ function extractParameters(func, inputMapping) {
 function extractDependencyCalls(func) {
   const results = [];
   func.forEachDescendant((node, traversal) => {
-    if (node !== func && (import_ts_morph55.Node.isFunctionDeclaration(node) || import_ts_morph55.Node.isFunctionExpression(node) || import_ts_morph55.Node.isArrowFunction(node) || import_ts_morph55.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph56.Node.isFunctionDeclaration(node) || import_ts_morph56.Node.isFunctionExpression(node) || import_ts_morph56.Node.isArrowFunction(node) || import_ts_morph56.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph55.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph56.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -11969,19 +12452,19 @@ function extractDependencyCalls(func) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph55.Node.isAwaitExpression(init)) {
+    if (import_ts_morph56.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph55.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph56.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph55.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph56.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph55.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph56.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -12107,6 +12590,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) {
@@ -12118,7 +12631,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
   );
   const extracted = extractRawBranches(
     func,
-    unit.terminals ?? pack.terminals,
+    terminalsFor(unit, pack),
     invocationRecognizers,
     accessRecognizers,
     barriers,
@@ -12154,8 +12667,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,
@@ -12179,8 +12691,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) {
@@ -12237,9 +12749,9 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
   if (m.type === "fromArgumentProperty") {
     const args = callSite.callExpression.getArguments();
     const arg = args[m.position];
-    if (arg !== void 0 && import_ts_morph55.Node.isObjectLiteralExpression(arg)) {
+    if (arg !== void 0 && import_ts_morph56.Node.isObjectLiteralExpression(arg)) {
       const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && import_ts_morph55.Node.isPropertyAssignment(prop)) {
+      if (prop !== void 0 && import_ts_morph56.Node.isPropertyAssignment(prop)) {
         const init = prop.getInitializer();
         if (init !== void 0) {
           const value = stringValueOf(init, resolution);
@@ -12368,22 +12880,22 @@ function extractBindingPath(binding, callSite, pack, resolution) {
   return void 0;
 }
 function pathFromUrlNode(node) {
-  if (import_ts_morph55.Node.isStringLiteral(node)) {
+  if (import_ts_morph56.Node.isStringLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph55.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph56.Node.isNoSubstitutionTemplateLiteral(node)) {
     return pathFromLiteralUrl(node.getLiteralValue());
   }
-  if (import_ts_morph55.Node.isTemplateExpression(node)) {
+  if (import_ts_morph56.Node.isTemplateExpression(node)) {
     return pathFromTemplateUrl(node);
   }
   return void 0;
 }
 function placeholderName(expr) {
-  if (import_ts_morph55.Node.isIdentifier(expr)) {
+  if (import_ts_morph56.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph55.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph56.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return "param";
@@ -12534,12 +13046,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;
@@ -12578,6 +13098,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,
@@ -12766,6 +13289,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",
@@ -12818,7 +13372,7 @@ function expandWrapperCallers(summaries, project, options) {
       continue;
     }
     const binding = s.identity.boundaryBinding;
-    if (binding === null || binding.semantics.name !== "rest" || binding.semantics.method === null || binding.semantics.path !== null) {
+    if (binding === null || binding.semantics.name !== "rest" || binding.semantics.method === null) {
       continue;
     }
     lookup ??= createSourceFileLookup(project);
@@ -12846,11 +13400,21 @@ function findWrapperPathParam(summary, lookup) {
   if (func === null) {
     return null;
   }
-  const params = func.getParameters();
-  if (params.length === 0) {
+  const names = func.getParameters().map((p) => p.getName());
+  if (names.length === 0) {
     return null;
   }
-  return { func, pathParamPosition: 0 };
+  for (const call of func.getDescendantsOfKind(import_ts_morph56.SyntaxKind.CallExpression)) {
+    const first = call.getArguments()[0];
+    if (first === void 0 || !import_ts_morph56.Node.isIdentifier(first)) {
+      continue;
+    }
+    const at = names.indexOf(first.getText());
+    if (at !== -1) {
+      return { func, pathParamPosition: at };
+    }
+  }
+  return null;
 }
 function synthesizeCallerSummaries(wrapper, _project, options) {
   const nameNode = wrapperNameNode(wrapper.func);
@@ -12891,16 +13455,16 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(func) || import_ts_morph55.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph56.Node.isFunctionDeclaration(func) || import_ts_morph56.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph55.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph56.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph55.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph56.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph55.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph56.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -12909,10 +13473,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph55.Node.isCallExpression(current2)) {
+    if (import_ts_morph56.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph55.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph56.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -12923,7 +13487,7 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph55.Node.isFunctionDeclaration(current2) || import_ts_morph55.Node.isFunctionExpression(current2) || import_ts_morph55.Node.isArrowFunction(current2) || import_ts_morph55.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph56.Node.isFunctionDeclaration(current2) || import_ts_morph56.Node.isFunctionExpression(current2) || import_ts_morph56.Node.isArrowFunction(current2) || import_ts_morph56.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -12931,13 +13495,13 @@ function enclosingFunction(node) {
   return null;
 }
 function literalOrTemplate(arg) {
-  if (import_ts_morph55.Node.isStringLiteral(arg)) {
+  if (import_ts_morph56.Node.isStringLiteral(arg)) {
     return arg.getLiteralValue();
   }
-  if (import_ts_morph55.Node.isNoSubstitutionTemplateLiteral(arg)) {
+  if (import_ts_morph56.Node.isNoSubstitutionTemplateLiteral(arg)) {
     return arg.getLiteralValue();
   }
-  if (import_ts_morph55.Node.isTemplateExpression(arg)) {
+  if (import_ts_morph56.Node.isTemplateExpression(arg)) {
     let path11 = arg.getHead().getLiteralText();
     for (const span of arg.getTemplateSpans()) {
       path11 += `{${placeholderName(span.getExpression())}}`;
@@ -12948,13 +13512,13 @@ function literalOrTemplate(arg) {
   return void 0;
 }
 function callerName(func) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(func) || import_ts_morph55.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph56.Node.isFunctionDeclaration(func) || import_ts_morph56.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph55.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph56.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph55.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph56.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -13006,8 +13570,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, storedProjectRoot) {
+  const projectRoot = storedProjectRoot ?? commonDirectoryOf(summaries.map((s) => s.location.file));
   nameSummaries(summaries, {
     workspace: workspace ?? workspaceNameFor(projectRoot),
     projectRoot
@@ -13059,7 +13623,7 @@ function loadRunFiles(project, candidatePaths, timer) {
   return { sourceFiles, deep };
 }
 function createTypeScriptAdapter(config) {
-  const project = config.project ?? new import_ts_morph55.Project(
+  const project = config.project ?? new import_ts_morph56.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -13138,7 +13702,29 @@ function createTypeScriptAdapter(config) {
         if (config.onTiming !== void 0) {
           config.onTiming(timer.report());
         }
-        return named(lookup.summaries, config.workspace);
+        return named(lookup.summaries, config.workspace, lookup.projectRoot);
+      }
+      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,
+          plan.storedProjectRoot ?? void 0
+        );
       }
       let candidatePaths = null;
       if (lazyEligible) {
@@ -13169,16 +13755,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,
@@ -13188,6 +13816,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;
@@ -13196,23 +13828,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",
@@ -13230,12 +13871,28 @@ function createTypeScriptAdapter(config) {
             access: collectAccessRecognizers(config.frameworks, tallies),
             resolveWrittenValue: (value) => resolution.resolveWrittenValue(value),
             resolveCallable: (value, alsoFrom) => resolution.resolveCallable(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(
@@ -13251,6 +13908,10 @@ function createTypeScriptAdapter(config) {
         "emitLibraryEnvReadMarkers",
         () => emitLibraryEnvReadMarkers(enriched, project, config.frameworks)
       );
+      timer.time(
+        "liftSchemasOntoDocuments",
+        () => liftSchemasOntoDocuments(enriched)
+      );
       timer.time(
         "stampGraphqlClientRefs",
         () => stampGraphqlClientRefs(
@@ -13260,12 +13921,45 @@ 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
+          }
+        });
+      }
+      const runProjectRoot = commonDirectoryOf(
+        sourceFiles.map((f) => f.getFilePath())
+      );
       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),
+            projectRoot: runProjectRoot
+          });
+          await cache.write(cacheInput, enriched, attribution);
         } catch {
         }
       });
@@ -13278,7 +13972,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(
@@ -13298,7 +13992,200 @@ function createTypeScriptAdapter(config) {
     }
   };
 }
-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,
+    ...args.projectRoot === void 0 ? {} : { projectRoot: args.projectRoot }
+  };
+}
+function synthesizeSubUnits(summaries, project, frameworks, options, tallies, onCreated) {
   const packByRecognition = /* @__PURE__ */ new Map();
   for (const pack of frameworks) {
     packByRecognition.set(pack.name, pack);
@@ -13341,6 +14228,7 @@ function synthesizeSubUnits(summaries, project, frameworks, options, tallies) {
       );
       if (summary !== null) {
         synthesized.push(summary);
+        onCreated?.(summary, parent);
       }
     }
   }
@@ -13349,14 +14237,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",
@@ -13402,7 +14283,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path10 = __toESM(require("path"), 1);
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -13450,12 +14331,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph56.Project({
+  const project = new import_ts_morph57.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph56.ScriptTarget.ES2022,
-      module: import_ts_morph56.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph56.ModuleResolutionKind.Bundler,
+      target: import_ts_morph57.ScriptTarget.ES2022,
+      module: import_ts_morph57.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph57.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -13495,10 +14376,10 @@ function findNearestTsconfig(startDir) {
 }
 
 // src/configuredCall.ts
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 function readConfiguredCall(call, ctx, spec) {
   const callee = call.getExpression();
-  if (!import_ts_morph57.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph58.Node.isPropertyAccessExpression(callee)) {
     return null;
   }
   if (callee.getName() !== spec.method) {
@@ -13543,10 +14424,10 @@ function readStringArg(arg) {
 }
 function rootIdentifier(node) {
   let current2 = node;
-  while (import_ts_morph57.Node.isPropertyAccessExpression(current2)) {
+  while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
     current2 = current2.getExpression();
   }
-  return import_ts_morph57.Node.isIdentifier(current2) ? current2 : null;
+  return import_ts_morph58.Node.isIdentifier(current2) ? current2 : null;
 }
 
 // src/packHealth.ts
@@ -13662,7 +14543,8 @@ function formatPackHealth(checks, audiences) {
 }
 
 // src/resolve/readName.ts
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -13676,6 +14558,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(),
@@ -13683,7 +14573,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_morph59.Node.isPropertyAccessExpression(step)) {
+    fields.unshift(step.getName());
+    step = step.getExpression();
+  }
+  if (!import_ts_morph59.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_morph59.Node.isParameterDeclaration(declaration)
+  );
 }
 function read(expr, ctx) {
   if (ctx.seen.has(expr)) {
@@ -13691,25 +14599,25 @@ function read(expr, ctx) {
   }
   const seen = new Set(ctx.seen).add(expr);
   const inner = { ...ctx, seen };
-  if (import_ts_morph58.Node.isStringLiteral(expr) || import_ts_morph58.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph59.Node.isStringLiteral(expr) || import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.getLiteralValue();
   }
-  if (import_ts_morph58.Node.isNumericLiteral(expr)) {
+  if (import_ts_morph59.Node.isNumericLiteral(expr)) {
     return expr.getLiteralText();
   }
-  if (import_ts_morph58.Node.isTemplateExpression(expr)) {
+  if (import_ts_morph59.Node.isTemplateExpression(expr)) {
     return fromTemplate(expr, inner);
   }
-  if (import_ts_morph58.Node.isParenthesizedExpression(expr)) {
+  if (import_ts_morph59.Node.isParenthesizedExpression(expr)) {
     return read(expr.getExpression(), inner);
   }
-  if (import_ts_morph58.Node.isBinaryExpression(expr)) {
+  if (import_ts_morph59.Node.isBinaryExpression(expr)) {
     return fromBinary(expr, inner);
   }
-  if (import_ts_morph58.Node.isCallExpression(expr)) {
+  if (import_ts_morph59.Node.isCallExpression(expr)) {
     return fromCall(expr, inner);
   }
-  if (import_ts_morph58.Node.isIdentifier(expr)) {
+  if (import_ts_morph59.Node.isIdentifier(expr)) {
     const only = boundOnce(expr, ctx);
     if (only !== null) {
       return read(only.node, { ...inner, bindings: only.scope });
@@ -13719,7 +14627,7 @@ function read(expr, ctx) {
   return written === null || written === expr ? null : read(written, inner);
 }
 function fromTemplate(expr, ctx) {
-  if (!import_ts_morph58.Node.isTemplateExpression(expr)) {
+  if (!import_ts_morph59.Node.isTemplateExpression(expr)) {
     return null;
   }
   let name = expr.getHead().getLiteralText();
@@ -13730,28 +14638,28 @@ function fromTemplate(expr, ctx) {
   return name;
 }
 function fromBinary(expr, ctx) {
-  if (!import_ts_morph58.Node.isBinaryExpression(expr)) {
+  if (!import_ts_morph59.Node.isBinaryExpression(expr)) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === import_ts_morph58.SyntaxKind.BarBarToken || operator === import_ts_morph58.SyntaxKind.QuestionQuestionToken) {
+  if (operator === import_ts_morph59.SyntaxKind.BarBarToken || operator === import_ts_morph59.SyntaxKind.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== import_ts_morph58.SyntaxKind.PlusToken) {
+  if (operator !== import_ts_morph59.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_morph58.Node.isCallExpression(expr)) {
+  if (!import_ts_morph59.Node.isCallExpression(expr)) {
     return null;
   }
   const callee = expr.getExpression();
-  if (import_ts_morph58.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
+  if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "join") {
     return fromJoin(callee.getExpression(), expr.getArguments(), ctx);
   }
-  if (import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === "String") {
+  if (import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === "String") {
     const only = expr.getArguments()[0];
     return only === void 0 ? null : readOrHole(only, ctx);
   }
@@ -13770,7 +14678,7 @@ function fromCall(expr, ctx) {
 }
 function fromJoin(subject, args, ctx) {
   const separator = args[0];
-  if (separator === void 0 || !import_ts_morph58.Node.isStringLiteral(separator)) {
+  if (separator === void 0 || !import_ts_morph59.Node.isStringLiteral(separator)) {
     return null;
   }
   const parts = elementsOf(subject, ctx);
@@ -13786,17 +14694,17 @@ function fromJoin(subject, args, ctx) {
   ).join(separator.getLiteralValue());
 }
 function elementsOf(subject, ctx) {
-  if (import_ts_morph58.Node.isArrayLiteralExpression(subject)) {
+  if (import_ts_morph59.Node.isArrayLiteralExpression(subject)) {
     return subject.getElements().map((element) => here(element, ctx));
   }
-  if (import_ts_morph58.Node.isCallExpression(subject)) {
+  if (import_ts_morph59.Node.isCallExpression(subject)) {
     const callee = subject.getExpression();
-    if (import_ts_morph58.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
+    if (import_ts_morph59.Node.isPropertyAccessExpression(callee) && callee.getName() === "map") {
       return elementsOf(callee.getExpression(), ctx);
     }
     return null;
   }
-  if (!import_ts_morph58.Node.isIdentifier(subject)) {
+  if (!import_ts_morph59.Node.isIdentifier(subject)) {
     return null;
   }
   const bound = ctx.bindings.get(subject.getText());
@@ -13804,7 +14712,7 @@ function elementsOf(subject, ctx) {
     return null;
   }
   const only = bound.length === 1 ? bound[0] : void 0;
-  return only !== void 0 && import_ts_morph58.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
+  return only !== void 0 && import_ts_morph59.Node.isArrayLiteralExpression(only.node) ? only.node.getElements().map((element) => here(element, ctx)) : bound;
 }
 function singleReturnBody(callee, ctx) {
   const declaration = declarationOf2(callee, ctx);
@@ -13819,22 +14727,22 @@ function singleReturnBody(callee, ctx) {
   if (body === void 0) {
     return null;
   }
-  if (import_ts_morph58.Node.isExpression(body)) {
+  if (import_ts_morph59.Node.isExpression(body)) {
     return { parameters, returned: body };
   }
-  if (!import_ts_morph58.Node.isBlock(body)) {
+  if (!import_ts_morph59.Node.isBlock(body)) {
     return null;
   }
   const statements = body.getStatements();
   const only = statements[0];
-  if (statements.length !== 1 || only === void 0 || !import_ts_morph58.Node.isReturnStatement(only)) {
+  if (statements.length !== 1 || only === void 0 || !import_ts_morph59.Node.isReturnStatement(only)) {
     return null;
   }
   const returned = only.getExpression();
   return returned === void 0 ? null : { parameters, returned };
 }
 function declarationOf2(callee, ctx) {
-  const symbol = import_ts_morph58.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
+  const symbol = import_ts_morph59.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getSymbol() : callee.getSymbol();
   const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
   for (const declaration of declarations) {
     const callable = asCallable(declaration);
@@ -13846,14 +14754,14 @@ function declarationOf2(callee, ctx) {
   return written === null || written === callee ? null : declarationOf2(written, { ...ctx, resolve: () => null });
 }
 function asCallable(declaration) {
-  if (import_ts_morph58.Node.isFunctionDeclaration(declaration) || import_ts_morph58.Node.isMethodDeclaration(declaration) || import_ts_morph58.Node.isArrowFunction(declaration) || import_ts_morph58.Node.isFunctionExpression(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)) {
     return declaration;
   }
-  if (!import_ts_morph58.Node.isVariableDeclaration(declaration)) {
+  if (!import_ts_morph59.Node.isVariableDeclaration(declaration)) {
     return null;
   }
   const initializer = declaration.getInitializer();
-  if (initializer !== void 0 && (import_ts_morph58.Node.isArrowFunction(initializer) || import_ts_morph58.Node.isFunctionExpression(initializer))) {
+  if (initializer !== void 0 && (import_ts_morph59.Node.isArrowFunction(initializer) || import_ts_morph59.Node.isFunctionExpression(initializer))) {
     return initializer;
   }
   return null;
@@ -13875,22 +14783,22 @@ function here(node, ctx) {
   return { node, scope: ctx.bindings };
 }
 function boundOnce(expr, ctx) {
-  const bound = import_ts_morph58.Node.isIdentifier(expr) ? ctx.bindings.get(expr.getText()) : void 0;
+  const bound = import_ts_morph59.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_morph58.Node.isIdentifier(expr)) {
+  if (import_ts_morph59.Node.isIdentifier(expr)) {
     return expr.getText();
   }
-  if (import_ts_morph58.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph59.Node.isPropertyAccessExpression(expr)) {
     return expr.getName();
   }
   return UNNAMED_HOLE;