@suss/adapter-typescript 0.9.0 → 0.10.0

package/dist/index.js

@@ -11,7 +11,11 @@ import {
   graphqlResolverBinding,
   messageBusBinding,
   packageExportBinding,
-  restBinding as restBinding2
+  readGraphqlMetadata as readGraphqlMetadata2,
+  readSourceDocumentMetadata,
+  restBinding as restBinding2,
+  withGraphqlMetadata as withGraphqlMetadata2,
+  withSourceDocumentMetadata
 } from "@suss/behavioral-ir";
 import { Database as Database5 } from "@suss/datalog";
 import {
@@ -1030,32 +1034,72 @@ function collectFallthroughCaseLabels(caseClause) {
 }
 
 // src/paths/pathConditions.ts
-import { Node as Node8 } from "ts-morph";
+import { Node as Node9 } from "ts-morph";
 import {
   enumerateStructuredPaths,
   PathBudgetExceeded,
   UnmodeledFlow as UnmodeledFlow2
 } from "@suss/extractor";
 
+// src/walk/descent.ts
+import { Node as Node7 } from "ts-morph";
+var NO_BARRIERS = /* @__PURE__ */ new Set();
+function isDescentStop(node, func, barriers = NO_BARRIERS) {
+  if (node === func) {
+    return false;
+  }
+  if (Node7.isFunctionDeclaration(node) || Node7.isMethodDeclaration(node)) {
+    return true;
+  }
+  if (Node7.isArrowFunction(node) || Node7.isFunctionExpression(node)) {
+    return barriers.has(node);
+  }
+  return false;
+}
+function isInlineCallback(node, func, barriers = NO_BARRIERS) {
+  if (node === func) {
+    return false;
+  }
+  if (!(Node7.isArrowFunction(node) || Node7.isFunctionExpression(node))) {
+    return false;
+  }
+  return !barriers.has(node);
+}
+function isModuleScopeStop(node) {
+  return Node7.isFunctionDeclaration(node) || Node7.isMethodDeclaration(node) || Node7.isArrowFunction(node) || Node7.isFunctionExpression(node) || Node7.isClassDeclaration(node) || Node7.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 Node7.isArrowFunction(node) || Node7.isFunctionExpression(node) || Node7.isFunctionDeclaration(node) || Node7.isMethodDeclaration(node) || Node7.isGetAccessorDeclaration(node) || Node7.isSetAccessorDeclaration(node) || Node7.isConstructorDeclaration(node);
+}
+
 // src/paths/lowering.ts
 import {
-  Node as Node7
+  Node as Node8
 } from "ts-morph";
 import {
   UnmodeledFlow
 } from "@suss/extractor";
-var isFunctionBoundary = (node) => Node7.isFunctionDeclaration(node) || Node7.isFunctionExpression(node) || Node7.isArrowFunction(node) || Node7.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 (Node7.isReturnStatement(node)) {
+    if (Node8.isReturnStatement(node)) {
       sawReturn = true;
     }
-    if (Node7.isThrowStatement(node)) {
+    if (Node8.isThrowStatement(node)) {
       sawThrow = true;
     }
     for (const child of node.getChildren()) {
@@ -1072,14 +1116,14 @@ var statementsOf = (stmt) => {
   if (stmt === void 0) {
     return [];
   }
-  if (Node7.isBlock(stmt)) {
+  if (Node8.isBlock(stmt)) {
     return stmt.getStatements();
   }
   return [stmt];
 };
-var isLoop = (stmt) => Node7.isForOfStatement(stmt) || Node7.isForInStatement(stmt) || Node7.isForStatement(stmt) || Node7.isWhileStatement(stmt) || Node7.isDoStatement(stmt);
+var isLoop = (stmt) => Node8.isForOfStatement(stmt) || Node8.isForInStatement(stmt) || Node8.isForStatement(stmt) || Node8.isWhileStatement(stmt) || Node8.isDoStatement(stmt);
 function getLoopBody(stmt) {
-  if (Node7.isForOfStatement(stmt) || Node7.isForInStatement(stmt) || Node7.isForStatement(stmt) || Node7.isWhileStatement(stmt) || Node7.isDoStatement(stmt)) {
+  if (Node8.isForOfStatement(stmt) || Node8.isForInStatement(stmt) || Node8.isForStatement(stmt) || Node8.isWhileStatement(stmt) || Node8.isDoStatement(stmt)) {
     return stmt.getStatement();
   }
   return void 0;
@@ -1094,37 +1138,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 (Node8.isIfStatement(stmt) || Node8.isSwitchStatement(stmt)) {
+    return [stmt.getExpression()];
+  }
+  if (Node8.isWhileStatement(stmt) || Node8.isDoStatement(stmt)) {
+    return [stmt.getExpression()];
+  }
+  if (Node8.isForOfStatement(stmt) || Node8.isForInStatement(stmt)) {
+    return [stmt.getInitializer(), stmt.getExpression()];
+  }
+  if (Node8.isForStatement(stmt)) {
+    return [
+      stmt.getInitializer(),
+      stmt.getCondition(),
+      stmt.getIncrementor()
+    ].filter((n) => n !== void 0);
+  }
+  if (Node8.isTryStatement(stmt)) {
+    return [];
+  }
+  if (Node8.isReturnStatement(stmt) || Node8.isThrowStatement(stmt)) {
+    const value = stmt.getExpression();
+    return value === void 0 ? [] : [value];
+  }
+  if (Node8.isBreakStatement(stmt) || Node8.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 && (Node8.isArrowFunction(node) || Node8.isFunctionExpression(node)) && isInlineCallback(node, ctx.func, ctx.barriers)) {
+      const body = node.getBody();
+      if (body !== void 0 && Node8.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) => Node7.isBlock(s) ? spliceBlocks(s.getStatements()) : [s]
+    (s) => Node8.isBlock(s) ? spliceBlocks(s.getStatements()) : [s]
   );
 }
-function buildStructured(stmt, rawToStructured) {
-  if (Node7.isIfStatement(stmt)) {
+function buildStructured(stmt, ctx) {
+  if (Node8.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 (Node7.isSwitchStatement(stmt)) {
+  if (Node8.isSwitchStatement(stmt)) {
     return {
       kind: "switch",
-      groups: lowerSwitchGroups(stmt, rawToStructured),
+      groups: lowerSwitchGroups(stmt, ctx),
       exitKind: exitKindOf(stmt)
     };
   }
@@ -1132,36 +1236,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 (Node7.isTryStatement(stmt)) {
+  if (Node8.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 (Node7.isReturnStatement(stmt)) {
+  if (Node8.isReturnStatement(stmt)) {
     return { kind: "exit", exit: "return", exitKind: exitKindOf(stmt) };
   }
-  if (Node7.isThrowStatement(stmt)) {
+  if (Node8.isThrowStatement(stmt)) {
     return { kind: "exit", exit: "throw", exitKind: exitKindOf(stmt) };
   }
-  if (Node7.isBreakStatement(stmt)) {
+  if (Node8.isBreakStatement(stmt)) {
     return { kind: "exit", exit: "break", exitKind: exitKindOf(stmt) };
   }
-  if (Node7.isContinueStatement(stmt)) {
+  if (Node8.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 = [];
@@ -1170,7 +1274,7 @@ function lowerSwitchGroups(stmt, rawToStructured) {
     if (sawDefault) {
       throw new UnmodeledFlow("default clause is not last");
     }
-    if (Node7.isDefaultClause(clause)) {
+    if (Node8.isDefaultClause(clause)) {
       sawDefault = true;
       const stmts2 = clause.getStatements();
       if (stmts2.length === 0) {
@@ -1178,11 +1282,11 @@ function lowerSwitchGroups(stmt, rawToStructured) {
       }
       groups.push({
         condition: null,
-        ...lowerGroupBody(stmts2, rawToStructured)
+        ...lowerGroupBody(stmts2, ctx)
       });
       continue;
     }
-    if (!Node7.isCaseClause(clause)) {
+    if (!Node8.isCaseClause(clause)) {
       continue;
     }
     pendingLabels.push(clause.getExpression().getText());
@@ -1195,7 +1299,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;
@@ -1203,41 +1307,42 @@ function lowerSwitchGroups(stmt, rawToStructured) {
 function validateClauseBreaks(stmts) {
   const last = stmts[stmts.length - 1];
   for (const stmt of stmts) {
-    if (stmt === last && Node7.isBreakStatement(stmt)) {
+    if (stmt === last && Node8.isBreakStatement(stmt)) {
       continue;
     }
-    if (Node7.isSwitchStatement(stmt) || isLoop(stmt)) {
+    if (Node8.isSwitchStatement(stmt) || isLoop(stmt)) {
       continue;
     }
     stmt.forEachDescendant((node, traversal) => {
-      if (isFunctionBoundary(node) || Node7.isSwitchStatement(node) || isLoop(node)) {
+      if (startsItsOwnScope(node) || Node8.isSwitchStatement(node) || isLoop(node)) {
         traversal.skip();
         return;
       }
-      if (Node7.isBreakStatement(node)) {
+      if (Node8.isBreakStatement(node)) {
         throw new UnmodeledFlow("non-trailing break in switch clause");
       }
     });
-    if (Node7.isBreakStatement(stmt)) {
+    if (Node8.isBreakStatement(stmt)) {
       throw new 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 && Node7.isBreakStatement(last);
+  const hasTrailingBreak = last !== void 0 && Node8.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) {
@@ -1259,7 +1364,7 @@ function lowerFunctionBody(body, terminalNodes) {
 function enclosingLoweredStatement(terminal, body, rawToStructured) {
   let current2 = terminal;
   while (current2 !== void 0 && current2 !== body) {
-    if (Node7.isStatement(current2) && rawToStructured.has(current2)) {
+    if (Node8.isStatement(current2) && rawToStructured.has(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -1268,39 +1373,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 (Node8.isLabeledStatement(node)) {
+    if (Node9.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 (!Node8.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 = Node9.isBlock(body) ? lowerFunctionBody(body, terminalNodes, func, barriers) : loweredExpressionBody(body, terminalNodes, func, barriers);
     const result = enumerateStructuredPaths({
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
@@ -1367,7 +1475,7 @@ function lineAt(node, pos) {
 }
 
 // src/moduleExports.ts
-import { Node as Node9 } from "ts-morph";
+import { Node as Node10 } from "ts-morph";
 
 // src/bootstrap/lazyProjectInit.ts
 import fs from "fs/promises";
@@ -1946,6 +2054,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();
@@ -1961,6 +2093,7 @@ function createPerFileCache() {
 
 // src/moduleExports.ts
 function exportedDeclarationsOf(sourceFile) {
+  recordFileDependency(sourceFile.getFilePath());
   const cached = exportsByFile.get(sourceFile);
   if (cached !== void 0) {
     return cached;
@@ -1975,7 +2108,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;
@@ -2090,7 +2230,7 @@ function reExportShapeOf(file, reach) {
   for (const assignment of file.getExportAssignments()) {
     exportNodes.push(assignment);
     const expression = assignment.getExpression();
-    if (Node9.isIdentifier(expression)) {
+    if (Node10.isIdentifier(expression)) {
       localNames.add(expression.getText());
     }
   }
@@ -2166,38 +2306,6 @@ function reportUnreadableExports(file) {
   );
 }
 
-// src/walk/descent.ts
-import { Node as Node10 } from "ts-morph";
-var NO_BARRIERS = /* @__PURE__ */ new Set();
-function isDescentStop(node, func, barriers = NO_BARRIERS) {
-  if (node === func) {
-    return false;
-  }
-  if (Node10.isFunctionDeclaration(node) || Node10.isMethodDeclaration(node)) {
-    return true;
-  }
-  if (Node10.isArrowFunction(node) || Node10.isFunctionExpression(node)) {
-    return barriers.has(node);
-  }
-  return false;
-}
-function isModuleScopeStop(node) {
-  return Node10.isFunctionDeclaration(node) || Node10.isMethodDeclaration(node) || Node10.isArrowFunction(node) || Node10.isFunctionExpression(node) || Node10.isClassDeclaration(node) || Node10.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 Node10.isArrowFunction(node) || Node10.isFunctionExpression(node) || Node10.isFunctionDeclaration(node) || Node10.isMethodDeclaration(node) || Node10.isGetAccessorDeclaration(node) || Node10.isSetAccessorDeclaration(node) || Node10.isConstructorDeclaration(node);
-}
-
 // src/resolve/invocationEffects.ts
 function isImportedFrom(identifier, expectedModule) {
   if (!Node11.isIdentifier(identifier)) {
@@ -4909,7 +5017,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"
@@ -4921,7 +5030,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 : [[]]
@@ -5052,7 +5165,7 @@ function indexFunctions(sf) {
 import { createHash as createHash2 } from "crypto";
 import fs2 from "fs/promises";
 import path2 from "path";
-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}$`);
@@ -5064,6 +5177,7 @@ function createCacheLayer(cacheDir) {
         kind: "miss",
         diagnostic: { kind: "miss", missReason: "no-manifest" }
       }),
+      plan: async () => null,
       write: async () => {
       }
     };
@@ -5091,20 +5205,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(path2.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(path2.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 fs2.mkdir(entryDir, { recursive: true });
       await fs2.writeFile(
         path2.join(entryDir, "manifest.json"),
@@ -5114,6 +5244,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 fs2.readFile(filePath);
+    return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+  } catch {
+    return null;
+  }
+}
 async function describeAbsentEntry(cacheDir) {
   try {
     const entries = await fs2.readdir(cacheDir, { withFileTypes: true });
@@ -5127,7 +5422,7 @@ function entryDirFor(cacheDir, input) {
     SCHEMA_VERSION,
     input.adapterPacksDigest,
     input.tsconfigPath ?? ""
-  ].join("\0");
+  ].join(" ");
   const name = createHash2("sha256").update(key).digest("hex").slice(0, 16);
   return path2.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
@@ -6986,7 +7281,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 (Node32.isArrowFunction(decoratorArg)) {
@@ -9550,7 +9845,10 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
           resolverInfo: {
             typeName,
             fieldName,
-            ...schemaSdl !== null ? { schemaSdl } : {}
+            ...schemaSdl !== null ? {
+              schemaSdl,
+              schemaDocument: config.getSourceFile().getFilePath()
+            } : {}
           }
         });
       }
@@ -9747,7 +10045,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();
@@ -9804,10 +10110,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) {
@@ -10086,6 +10397,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;
@@ -10146,7 +10459,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(
@@ -10154,7 +10470,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;
   }
   /**
@@ -10188,6 +10507,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 = [];
@@ -10196,6 +10516,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));
       }
@@ -10495,6 +10817,27 @@ function moduleInitSummary(sourceFile, effects, options) {
   return 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
 import { evaluate as evaluate3, lit as lit3, rule as rule3, variable } from "@suss/datalog";
 var EFFECT_RULES = [
@@ -10679,6 +11022,11 @@ function classifyStop(declarations) {
   if (declarations.length === 0) {
     return "noDeclaration";
   }
+  for (const declaration of declarations) {
+    if (!isInExternalCode(declaration.getSourceFile())) {
+      recordFileDependency(declaration.getSourceFile().getFilePath());
+    }
+  }
   if (declarations.every(isExternalDeclaration)) {
     return "outsideRun";
   }
@@ -10885,7 +11233,7 @@ var REACHABLE_RULES = [
   )
 ];
 var NO_RECOGNIZERS = { invocation: [], access: [] };
-function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS) {
+function expandReachableClosure(seeds, project, options, projectFileSet, facts, recognizers = NO_RECOGNIZERS, alreadySummarized = []) {
   const lookup = createSourceFileLookup(project);
   const db = facts?.db ?? new Database3();
   const functionByKey = /* @__PURE__ */ new Map();
@@ -10905,6 +11253,15 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
       db.add("entry", [key]);
     }
   }
+  const knownKeys = /* @__PURE__ */ new Set();
+  for (const summary of alreadySummarized) {
+    const func = lookup.functionAt(summary.location);
+    if (func !== null) {
+      const key = nodeKey2(func);
+      knownKeys.add(key);
+      facts?.unitKeyBySummary.set(summary, key);
+    }
+  }
   for (; ; ) {
     evaluate4(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
@@ -10922,7 +11279,11 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
         ...recognizers.resolveCallable === void 0 ? {} : { resolveCallable: recognizers.resolveCallable },
         ...cameFrom === void 0 ? {} : { reachedFrom: cameFrom }
       };
-      const { candidates, stops } = collectReachable(source.func, scan);
+      const { candidates, stops } = scanWithRecording(
+        key,
+        facts,
+        () => collectReachable(source.func, scan)
+      );
       if (stops.length > 0) {
         stopsByKey.set(key, stops);
       }
@@ -10941,7 +11302,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);
@@ -10955,7 +11316,11 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
         candidate.func.getSourceFile().getFilePath()
       );
     }
-    const summary = extractReachableSummary(candidate, options, recognizers);
+    const summary = scanWithRecording(
+      key,
+      facts,
+      () => extractReachableSummary(candidate, options, recognizers)
+    );
     facts?.unitKeyBySummary.set(summary, key);
     rememberSummary(summariesByKey, key, summary);
     reached.push(summary);
@@ -10963,6 +11328,20 @@ function expandReachableClosure(seeds, project, options, projectFileSet, facts,
   recordStops(stopsByKey, summariesByKey, options);
   return [...seeds, ...reached];
 }
+function scanWithRecording(key, facts, fn) {
+  const filesByKey = facts?.filesByKey;
+  if (filesByKey === void 0) {
+    return fn();
+  }
+  const sink = createDependencySink();
+  const result = withDependencySink(sink, fn);
+  const bucket = filesByKey.get(key) ?? /* @__PURE__ */ new Set();
+  for (const filePath of sink.files) {
+    bucket.add(filePath);
+  }
+  filesByKey.set(key, bucket);
+  return result;
+}
 function rememberSummary(summariesByKey, key, summary) {
   const bucket = summariesByKey.get(key) ?? [];
   bucket.push(summary);
@@ -12224,6 +12603,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) {
@@ -12235,7 +12644,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
   );
   const extracted = extractRawBranches(
     func,
-    unit.terminals ?? pack.terminals,
+    terminalsFor(unit, pack),
     invocationRecognizers,
     accessRecognizers,
     barriers,
@@ -12271,8 +12680,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,
@@ -12296,8 +12704,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) {
@@ -12651,12 +13059,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;
@@ -12695,6 +13111,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,
@@ -12883,6 +13302,37 @@ function fileImporting(project, modulePrefix) {
   }
   return void 0;
 }
+function liftSchemasOntoDocuments(summaries) {
+  const sdlByDocument = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const label = readSourceDocumentMetadata(summary)?.label;
+    const graphql = readGraphqlMetadata2(summary);
+    if (label === void 0 || graphql?.schemaSdl === void 0) {
+      continue;
+    }
+    sdlByDocument.set(label, graphql.schemaSdl);
+    const { schemaSdl: _movedToTheDocument, ...rest } = graphql;
+    summary.metadata = withGraphqlMetadata2(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: withGraphqlMetadata2(
+      withSourceDocumentMetadata(void 0, { label }),
+      { schemaSdl }
+    )
+  };
+}
 function libraryEnvReadMarker(pack, declared, importer) {
   return {
     kind: "library",
@@ -13133,8 +13583,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
@@ -13265,7 +13715,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) {
@@ -13296,16 +13768,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,
@@ -13315,6 +13829,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;
@@ -13323,23 +13841,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 Database5(),
-        unitKeyBySummary: /* @__PURE__ */ new Map()
+        unitKeyBySummary: /* @__PURE__ */ new Map(),
+        ...caching ? { filesByKey: /* @__PURE__ */ new Map() } : {}
       };
       const withClosure = config.includeReachable !== false ? timer.time(
         "expandReachableClosure",
@@ -13357,12 +13884,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(
@@ -13378,6 +13921,10 @@ function createTypeScriptAdapter(config) {
         "emitLibraryEnvReadMarkers",
         () => emitLibraryEnvReadMarkers(enriched, project, config.frameworks)
       );
+      timer.time(
+        "liftSchemasOntoDocuments",
+        () => liftSchemasOntoDocuments(enriched)
+      );
       timer.time(
         "stampGraphqlClientRefs",
         () => stampGraphqlClientRefs(
@@ -13387,12 +13934,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 {
         }
       });
@@ -13405,7 +13985,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(
@@ -13425,7 +14005,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 (readSourceDocumentMetadata(summary) !== void 0) {
+    return true;
+  }
+  if (readGraphqlMetadata2(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);
@@ -13468,6 +14241,7 @@ function synthesizeSubUnits(summaries, project, frameworks, options, tallies) {
       );
       if (summary !== null) {
         synthesized.push(summary);
+        onCreated?.(summary, parent);
       }
     }
   }
@@ -13476,14 +14250,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",
@@ -13795,6 +14562,7 @@ function formatPackHealth(checks, audiences) {
 
 // src/resolve/readName.ts
 import { Node as Node56, SyntaxKind as SyntaxKind12 } from "ts-morph";
+import { patternHole, referenceName } from "@suss/behavioral-ir";
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -13808,6 +14576,14 @@ function readName(expr, options = {}) {
   if (name !== null || options.unsettled !== "reference") {
     return name;
   }
+  const reference = referenceIn(expr);
+  return reference === null ? null : referenceName(reference);
+}
+function referenceIn(expr) {
+  const fromParameter = parameterPath(expr);
+  if (fromParameter !== null) {
+    return fromParameter;
+  }
   const asked = holeName(expr, {
     resolve: () => null,
     bindings: /* @__PURE__ */ new Map(),
@@ -13815,7 +14591,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 (Node56.isPropertyAccessExpression(step)) {
+    fields.unshift(step.getName());
+    step = step.getExpression();
+  }
+  if (!Node56.isIdentifier(step) || !isParameter(step)) {
+    return null;
+  }
+  return { root: step.getText(), fields };
+}
+function isParameter(identifier) {
+  const declarations = identifier.getSymbol()?.getDeclarations() ?? [];
+  return declarations.some(
+    (declaration) => Node56.isParameterDeclaration(declaration)
+  );
 }
 function read(expr, ctx) {
   if (ctx.seen.has(expr)) {
@@ -14012,7 +14806,7 @@ function boundOnce(expr, ctx) {
 }
 function readOrHole(expr, ctx) {
   const name = read(expr, ctx);
-  return name ?? `{${holeName(expr, ctx)}}`;
+  return name ?? patternHole(holeName(expr, ctx));
 }
 function holeName(expr, ctx) {
   const bound = boundOnce(expr, ctx);