@suss/extractor 0.34.0 → 0.35.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
   effectKey,
   exchangesHttpResponses as exchangesHttpResponses2,
@@ -199,29 +199,82 @@ function composeOne(summary, chain, keepGaps) {
   if (wrappers.length === 0) {
     return narrowed;
   }
-  const responses = respondedInstead(wrappers);
-  const handled = handledThrows(wrappers);
-  const transitions = beside(summary, responses, handled);
+  const responses = settledUncaught(respondedInstead(wrappers), wrappers);
+  const unitOwn = settledUncaught(summary.transitions, wrappers);
+  const own = [...responses, ...unitOwn];
+  const handled = handledThrows(wrappers, thrownBy(own));
+  const transitions = beside(summary, unitOwn, responses, handled);
   if (!keepGaps) {
     return transitions === summary.transitions ? narrowed : { ...narrowed, transitions };
   }
   const gaps = withContractStatusGaps(
     summary,
-    [...responses, ...summary.transitions],
-    handled
+    own,
+    everyHandlerOutcome(wrappers)
   );
   if (transitions === summary.transitions && gaps === summary.gaps) {
     return narrowed;
   }
   return { ...narrowed, transitions, gaps };
 }
-function beside(summary, responses, handled) {
-  const throws = summary.transitions.some((t) => t.output.type === "throw");
-  const onThrow = throws ? handled : [];
-  if (responses.length === 0 && onThrow.length === 0) {
+function beside(summary, unitOwn, responses, handled) {
+  if (responses.length === 0 && handled.length === 0 && unitOwn === summary.transitions) {
     return summary.transitions;
   }
-  return withDistinctIds([...responses, ...summary.transitions, ...onThrow]);
+  return withDistinctIds([...responses, ...unitOwn, ...handled]);
+}
+function settledUncaught(transitions, wrappers) {
+  const handlers = wrappers.filter(
+    (wrapper) => wrapper.reference.onThrow === true
+  );
+  let changed = false;
+  const settled = transitions.flatMap((transition) => {
+    const { output } = transition;
+    if (output.type !== "throw") {
+      return [transition];
+    }
+    const caught = caughtOnRoute(handlers, output);
+    if (caught === "sure") {
+      changed = true;
+      return [markedCaught(transition)];
+    }
+    if (output.statusWhenUncaught === void 0) {
+      return [transition];
+    }
+    changed = true;
+    const response = {
+      ...transition,
+      output: {
+        type: "response",
+        statusCode: { type: "literal", value: output.statusWhenUncaught },
+        body: null,
+        headers: {}
+      }
+    };
+    return caught === "uncertain" ? [transition, response] : [response];
+  });
+  return changed ? settled : transitions;
+}
+function markedCaught(transition) {
+  return {
+    ...transition,
+    metadata: withWrapperMetadata(transition.metadata, {
+      ...readWrapperMetadata2(transition),
+      caught: true
+    })
+  };
+}
+function caughtOnRoute(handlers, thrown) {
+  if (handlers.some((handler) => handler.reference.catches === void 0)) {
+    return "sure";
+  }
+  const matches = handlers.map(
+    (handler) => catchMatch(handler.reference, thrown)
+  );
+  if (matches.includes("yes")) {
+    return "sure";
+  }
+  return matches.includes("maybe") ? "uncertain" : "no";
 }
 function respondedInstead(wrappers) {
   return wrappers.flatMap(
@@ -233,11 +286,91 @@ function respondedInstead(wrappers) {
     )
   );
 }
-function handledThrows(wrappers) {
+function thrownBy(transitions) {
+  return transitions.flatMap(
+    (t) => t.output.type === "throw" ? [t.output] : []
+  );
+}
+function everyHandlerOutcome(wrappers) {
   return wrappers.flatMap(
     (wrapper) => wrapper.reference.onThrow === true ? attribute(wrapper.summary.transitions, wrapper.reference) : []
   );
 }
+function handledThrows(wrappers, thrown) {
+  const caught = catchesAny(wrappers, thrown);
+  return [...oncePerHandler(wrappers, caught)].flatMap(
+    ([wrapper, how]) => attribute(
+      wrapper.summary.transitions,
+      wrapper.reference,
+      how === "uncertain"
+    )
+  );
+}
+function oncePerHandler(wrappers, caught) {
+  const byHandler = /* @__PURE__ */ new Map();
+  for (const wrapper of wrappers) {
+    const how = caught.get(wrapper);
+    if (how === void 0) {
+      continue;
+    }
+    const earlier = byHandler.get(wrapper.summary);
+    if (earlier === void 0 || earlier[1] === "uncertain" && how === "sure") {
+      byHandler.set(wrapper.summary, [wrapper, how]);
+    }
+  }
+  return new Map(byHandler.values());
+}
+function catchesAny(wrappers, thrown) {
+  const caught = /* @__PURE__ */ new Map();
+  if (thrown.length === 0) {
+    return caught;
+  }
+  const handlers = wrappers.filter(
+    (wrapper) => wrapper.reference.onThrow === true
+  );
+  for (const handler of handlers) {
+    if (handler.reference.catches === void 0) {
+      caught.set(handler, "sure");
+    }
+  }
+  const listing = handlers.filter(
+    (handler) => handler.reference.catches !== void 0
+  );
+  for (const one of thrown) {
+    for (const [handler, how] of catchersOf(listing, one)) {
+      if (caught.get(handler) !== "sure") {
+        caught.set(handler, how);
+      }
+    }
+  }
+  return caught;
+}
+function catchersOf(handlers, thrown) {
+  const found = [];
+  for (const handler of handlers) {
+    const match = catchMatch(handler.reference, thrown);
+    if (match === "yes") {
+      found.push([handler, found.length === 0 ? "sure" : "uncertain"]);
+      return found;
+    }
+    if (match === "maybe") {
+      found.push([handler, "uncertain"]);
+    }
+  }
+  return found;
+}
+function catchMatch(reference, thrown) {
+  const ancestors = thrown.exceptionAncestors;
+  if (thrown.exceptionType === null || ancestors === void 0) {
+    return "maybe";
+  }
+  const classes = /* @__PURE__ */ new Set([thrown.exceptionType, ...ancestors]);
+  if ((reference.catches ?? []).some((name) => classes.has(name))) {
+    return "yes";
+  }
+  const unread = thrown.ancestryIncomplete === true && reference.mayCatchUnreadClasses === true;
+  return unread || reference.mayCatchAny === true ? "maybe" : "no";
+}
 function withContractStatusGaps(summary, composed, handled) {
   const contract = readHttpMetadata(summary)?.declaredContract;
   const binding = summary.identity.boundaryBinding;
@@ -268,10 +401,13 @@ function coversUnit(reference, summary) {
   const binding = summary.identity.boundaryBinding;
   return binding !== null && withinScope(binding, reference.scope);
 }
-function attribute(transitions, reference) {
+function attribute(transitions, reference, catchUncertain = false) {
   return transitions.map((transition) => ({
     ...transition,
-    metadata: withWrapperMetadata(transition.metadata, { from: reference })
+    metadata: withWrapperMetadata(transition.metadata, {
+      from: reference,
+      ...catchUncertain ? { catchUncertain } : {}
+    })
   }));
 }
 function withDistinctIds(transitions) {
@@ -384,13 +520,111 @@ function markExitCodeFrom(summary, marked) {
   summary.metadata = left;
 }
 
+// src/helperHandOff.ts
+import { predicateRefs, replacePredicateRefs } from "@suss/behavioral-ir";
+var MAX_HELPER_PATHS = 16;
+function throughHelper(branch, at, helperBranches) {
+  return helperBranches.map((helper) => {
+    const conditions = [...branch.conditions, ...helper.conditions];
+    const expectedInput = mergeReadShapes(
+      branch.expectedInput ?? null,
+      helper.expectedInput ?? null
+    );
+    const reads = expectedInput === null ? {} : { expectedInput };
+    if (helper.terminal.kind !== "throw" && helper.terminal.kind !== "exit") {
+      return {
+        ...branch,
+        ...reads,
+        conditions,
+        isDefault: branch.isDefault && helper.isDefault
+      };
+    }
+    return {
+      ...branch,
+      ...reads,
+      conditions,
+      terminal: { ...helper.terminal, location: at },
+      location: at,
+      isDefault: false
+    };
+  });
+}
+function mergeReadShapes(a, b) {
+  if (a === null || b === null) {
+    return a ?? b;
+  }
+  if (a.type !== "record" || b.type !== "record") {
+    return a.type === "record" ? a : b;
+  }
+  const properties = { ...a.properties };
+  for (const [name, shape] of Object.entries(b.properties)) {
+    const known = properties[name];
+    properties[name] = known === void 0 ? shape : mergeReadShapes(known, shape) ?? shape;
+  }
+  return { ...a, properties };
+}
+function splitAtHandOffs(branch, sites, from = 0) {
+  for (let index = from; index < sites.length; index++) {
+    const site = sites[index];
+    const reached = site.alwaysRuns === true || runsBefore(site.line, branch.terminal.location.end);
+    if (!reached || !guardsHoldOn(site.preconditions, branch.conditions)) {
+      continue;
+    }
+    return throughHelper(branch, site.at, site.helper).flatMap(
+      (path10) => path10.terminal === branch.terminal ? splitAtHandOffs(path10, sites, index + 1) : [path10]
+    );
+  }
+  return [branch];
+}
+function helperPathsOnVariables(helperBranches, passed) {
+  const renamed = helperBranches.map((branch) => ({
+    ...branch,
+    conditions: branch.conditions.map((condition) => ({
+      ...condition,
+      structured: condition.structured === null ? null : onCallerVariables(condition.structured, passed)
+    }))
+  }));
+  const variables = new Set(passed.values());
+  const testsWhatItGot = renamed.some(
+    (branch) => branch.conditions.some(
+      (condition) => condition.structured !== null && predicateRefs(condition.structured).some(
+        (ref) => variables.has(rootName(ref) ?? "")
+      )
+    )
+  );
+  return testsWhatItGot && renamed.length <= MAX_HELPER_PATHS ? renamed : null;
+}
+function onCallerVariables(predicate, passed) {
+  const rename = (ref) => {
+    if (ref.type === "derived") {
+      return { ...ref, from: rename(ref.from) };
+    }
+    if (ref.type === "input") {
+      const name = passed.get(ref.inputRef);
+      return name === void 0 ? ref : { type: "dependency", name, accessChain: ref.path };
+    }
+    if (ref.type === "dependency") {
+      const name = passed.get(ref.name);
+      return name === void 0 ? ref : { ...ref, name };
+    }
+    return ref;
+  };
+  return replacePredicateRefs(predicate, rename);
+}
+function rootName(ref) {
+  if (ref.type === "derived") {
+    return rootName(ref.from);
+  }
+  return ref.type === "dependency" ? ref.name : null;
+}
+
 // src/moduleImports.ts
-function stampModuleImports(summaries, importsOf) {
+function stampModuleImports(summaries, importsOf2) {
   const byFile = /* @__PURE__ */ new Map();
   for (const summary of summaries) {
     const file = summary.location.file;
     if (!byFile.has(file)) {
-      const found = importsOf(file);
+      const found = importsOf2(file);
       byFile.set(
         file,
         found === void 0 ? void 0 : [...new Set(found)].sort()
@@ -685,8 +919,8 @@ var catchEntryCond = () => fixedCond(
   "positive",
   "catchBlock"
 );
-function classify(path6, home, isAncestorOrSelf) {
-  return path6.map((cond) => {
+function classify(path10, home, isAncestorOrSelf) {
+  return path10.map((cond) => {
     if (cond.branchStmt === null) {
       return cond.info;
     }
@@ -751,9 +985,16 @@ function chargeBudget(state) {
     );
   }
 }
-function recordTerminal(ctx, terminal, home, path6) {
+function limitOpenPaths(paths) {
+  if (paths.length > MAX_PATHS) {
+    throw new PathBudgetExceeded(
+      `path budget exceeded, more than ${MAX_PATHS} paths`
+    );
+  }
+}
+function recordTerminal(ctx, terminal, home, path10) {
   chargeBudget(ctx.state);
-  const info = classify(path6, home, ctx.isAncestorOrSelf);
+  const info = classify(path10, home, ctx.isAncestorOrSelf);
   const existing = ctx.state.byTerminal.get(terminal) ?? [];
   existing.push(info);
   ctx.state.byTerminal.set(terminal, existing);
@@ -764,15 +1005,15 @@ function containsTerminal(ctx, stmt) {
   }
   return childrenOf(stmt).some((child) => containsTerminal(ctx, child));
 }
-function stepIf(stmt, path6, ctx) {
+function stepIf(stmt, path10, ctx) {
   const thenExit = exitKindOfList(stmt.thenBody);
   const elseExit = stmt.elseBody === null ? null : exitKindOfList(stmt.elseBody);
   const thenPath = [
-    ...path6,
+    ...path10,
     branchCond(stmt, stmt.condition, "positive", elseExit)
   ];
   const elsePath = [
-    ...path6,
+    ...path10,
     branchCond(
       stmt,
       stmt.condition,
@@ -789,7 +1030,7 @@ function stepIf(stmt, path6, ctx) {
   }
   return out;
 }
-function stepSwitch(stmt, path6, ctx) {
+function stepSwitch(stmt, path10, ctx) {
   const out = [];
   const negations = [];
   let defaultRanBody = false;
@@ -799,7 +1040,7 @@ function stepSwitch(stmt, path6, ctx) {
     if (hasStrayBreak(group.body)) {
       throw new UnmodeledFlow("non-trailing break in switch clause");
     }
-    const groupPath = group.condition === null ? [...path6, ...negations] : [...path6, fixedCond(group.condition, "positive", "explicit")];
+    const groupPath = group.condition === null ? [...path10, ...negations] : [...path10, fixedCond(group.condition, "positive", "explicit")];
     const conts = enumerate(ctx, group.body, groupPath);
     if (conts.length > 0) {
       if (!group.hasTrailingBreak && !fallthroughSafe) {
@@ -816,24 +1057,24 @@ function stepSwitch(stmt, path6, ctx) {
     }
   }
   if (!defaultRanBody) {
-    out.push([...path6, ...negations]);
+    out.push([...path10, ...negations]);
   }
   return out;
 }
-function stepLoop(stmt, path6, ctx) {
+function stepLoop(stmt, path10, ctx) {
   const bodyExit = exitKindOfList(stmt.body);
   if (containsTerminal(ctx, stmt)) {
     enumerate(ctx, stmt.body, [
-      ...path6,
+      ...path10,
       loopIterationCond(stmt.condition.sourceText)
     ]);
   }
   if (bodyExit !== null) {
-    return [[...path6, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
+    return [[...path10, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
   }
-  return [path6];
+  return [path10];
 }
-function stepTry(stmt, path6, ctx) {
+function stepTry(stmt, path10, ctx) {
   if (stmt.finallyBody !== null) {
     const finallyHasTerminal = stmt.finallyBody.some(
       (s) => containsTerminal(ctx, s)
@@ -843,22 +1084,22 @@ function stepTry(stmt, path6, ctx) {
     }
   }
   const out = [];
-  out.push(...enumerate(ctx, stmt.tryBody, path6));
+  out.push(...enumerate(ctx, stmt.tryBody, path10));
   if (stmt.catchBody !== null) {
-    const catchPath = [...path6, catchEntryCond()];
+    const catchPath = [...path10, catchEntryCond()];
     out.push(...enumerate(ctx, stmt.catchBody, catchPath));
   }
   return out;
 }
-function stepExit(stmt, path6, ctx) {
+function stepExit(stmt, path10, ctx) {
   const collector = ctx.state.callbackExits[ctx.state.callbackExits.length - 1];
   if (collector !== void 0 && (stmt.exit === "return" || stmt.exit === "throw")) {
-    collector.push(path6);
+    collector.push(path10);
   }
   return [];
 }
-function stepOpaque(_stmt, path6, _ctx) {
-  return [path6];
+function stepOpaque(_stmt, path10, _ctx) {
+  return [path10];
 }
 var stepHandlers = {
   if: stepIf,
@@ -868,22 +1109,23 @@ var stepHandlers = {
   exit: stepExit,
   opaque: stepOpaque
 };
-function stepCallback(ctx, body, path6) {
+function stepCallback(ctx, body, path10) {
   const exits = [];
   ctx.state.callbackExits.push(exits);
   let fellThrough;
   try {
-    fellThrough = enumerate(ctx, body, path6);
+    fellThrough = enumerate(ctx, body, path10);
   } finally {
     ctx.state.callbackExits.pop();
   }
   const out = [...fellThrough, ...exits];
-  return out.length === 0 ? [path6] : out;
+  return out.length === 0 ? [path10] : out;
 }
-function stepStatement(ctx, stmt, path6) {
-  let paths = [path6];
+function stepStatement(ctx, stmt, path10) {
+  let paths = [path10];
   for (const body of stmt.callbacks ?? []) {
     paths = paths.flatMap((each) => stepCallback(ctx, body, each));
+    limitOpenPaths(paths);
   }
   const ownTerminals = ctx.terminalsByStmt.get(stmt) ?? [];
   for (const each of withRejoined(paths)) {
@@ -900,7 +1142,7 @@ function stepStatement(ctx, stmt, path6) {
     )
   );
 }
-function soleDisagreement(left, right) {
+function soleDisagreement(left, right, keepsArms) {
   if (left.length !== right.length) {
     return null;
   }
@@ -919,9 +1161,10 @@ function soleDisagreement(left, right) {
     }
     found = at;
   }
-  return found;
+  const test = found === null ? null : left[found]?.info.expression ?? null;
+  return test !== null && keepsArms(test) ? null : found;
 }
-function mergeRejoined(paths) {
+function mergeRejoined(paths, keepsArms = KEEPS_NO_ARMS) {
   let current = paths;
   for (let round = 0; round < current.length; round++) {
     const out = [];
@@ -936,7 +1179,11 @@ function mergeRejoined(paths) {
         if (taken.has(j)) {
           continue;
         }
-        const at = soleDisagreement(combined, current[j]);
+        const at = soleDisagreement(
+          combined,
+          current[j],
+          keepsArms
+        );
         if (at === null) {
           continue;
         }
@@ -962,21 +1209,18 @@ function enumerate(ctx, stmts, prefix) {
   let frontiers = [[...prefix]];
   for (const stmt of stmts) {
     const nextFrontiers = [];
-    for (const path6 of mergeRejoined(frontiers)) {
-      nextFrontiers.push(...stepStatement(ctx, stmt, path6));
+    for (const path10 of mergeRejoined(frontiers, ctx.keepsArms)) {
+      nextFrontiers.push(...stepStatement(ctx, stmt, path10));
     }
     frontiers = nextFrontiers;
-    if (frontiers.length > MAX_PATHS) {
-      throw new PathBudgetExceeded(
-        `path budget exceeded, more than ${MAX_PATHS} paths`
-      );
-    }
+    limitOpenPaths(frontiers);
     if (frontiers.length === 0) {
       break;
     }
   }
   return frontiers;
 }
+var KEEPS_NO_ARMS = () => false;
 function buildParentMap(statements) {
   const parentOf = /* @__PURE__ */ new Map();
   const visit = (stmt, parent) => {
@@ -1010,13 +1254,14 @@ function enumerateStructuredPaths(input) {
   };
   const ctx = {
     terminalsByStmt: input.terminalsByStmt,
+    keepsArms: input.keepsArms ?? KEEPS_NO_ARMS,
     state,
     isAncestorOrSelf
   };
   const continuations = withRejoined(enumerate(ctx, input.statements, []));
-  for (const path6 of continuations) {
+  for (const path10 of continuations) {
     chargeBudget(state);
-    state.fallthrough.push(classify(path6, null, isAncestorOrSelf));
+    state.fallthrough.push(classify(path10, null, isAncestorOrSelf));
   }
   return { byTerminal: state.byTerminal, fallthrough: state.fallthrough };
 }
@@ -1059,8 +1304,8 @@ function sharedGatingConditions(paths, readPredicate) {
     return [];
   }
   const shared = new Set(first.map(keyOf2));
-  for (const path6 of rest) {
-    const here = new Set(path6.map(keyOf2));
+  for (const path10 of rest) {
+    const here = new Set(path10.map(keyOf2));
     for (const value of shared) {
       if (!here.has(value)) {
         shared.delete(value);
@@ -1168,15 +1413,12 @@ var EnclosingNodes = class {
 
 // src/paths/nodeWalk.ts
 var SKIP_CHILDREN = /* @__PURE__ */ Symbol("skipChildren");
-function walkDescendants(root, carried, visitor) {
-  for (const child of root.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+function walkDescendants(root, carried, childrenOf2, visitor) {
+  for (const child of childrenOf2(root)) {
     visitor.at(child, carried);
     const inner = visitor.into(child, carried);
     if (inner !== SKIP_CHILDREN) {
-      walkDescendants(child, inner, visitor);
+      walkDescendants(child, inner, childrenOf2, visitor);
     }
   }
 }
@@ -1255,6 +1497,11 @@ function valueToReadFurtherFrom(reading) {
   return reading.kind === "written" ? reading.value : null;
 }
 
+// src/redirectOption.ts
+function redirectDeliveryWhenSet(option, value) {
+  return option.handsBack.includes(value) ? "response" : "followed";
+}
+
 // src/testFiles.ts
 function isListedTestFile(file, listed) {
   if (listed === void 0) {
@@ -1324,17 +1571,179 @@ function quoted(text, key) {
 }
 
 // src/adapterStamp.ts
+import { createHash as createHash2 } from "crypto";
+import fs3 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+
+// src/codeHash.ts
 import { createHash } from "crypto";
 import fs2 from "fs";
 import { createRequire } from "module";
 import path4 from "path";
-import { fileURLToPath } from "url";
-var ANALYSIS_PACKAGES = [
-  "@suss/extractor",
-  "@suss/resolution",
-  "@suss/datalog",
-  "@suss/behavioral-ir"
-];
+var SUSS_SCOPE = "@suss/";
+var IMPORT_FORMS = /\b(?:from|import)\s*\(?\s*["']([^"'\s]+)["']|require\s*\(\s*["']([^"'\s]+)["']/g;
+var CONDITIONS = {
+  import: /* @__PURE__ */ new Set(["import", "node", "default"]),
+  require: /* @__PURE__ */ new Set(["require", "node", "default"])
+};
+function createCodeHasher() {
+  const read = /* @__PURE__ */ new Map();
+  function readOnce(file) {
+    const known = read.get(file);
+    if (known !== void 0) {
+      return known;
+    }
+    const found = readCodeFile(file);
+    read.set(file, found);
+    return found;
+  }
+  function codeFiles(entryFile) {
+    const entry = realFile(entryFile);
+    if (entry === null || readOnce(entry) === null) {
+      return [];
+    }
+    const found = [entry];
+    const seen = new Set(found);
+    for (let at = 0; at < found.length; at++) {
+      for (const next of readOnce(found[at])?.imports ?? []) {
+        if (seen.has(next)) {
+          continue;
+        }
+        seen.add(next);
+        if (readOnce(next) !== null) {
+          found.push(next);
+        }
+      }
+    }
+    return found;
+  }
+  function codeHash(entryFile) {
+    const files = codeFiles(entryFile);
+    if (files.length === 0) {
+      return "";
+    }
+    const hash = createHash("sha256");
+    for (const file of files) {
+      hash.update(read.get(file)?.digest ?? "");
+    }
+    return hash.digest("hex").slice(0, 16);
+  }
+  return { codeFiles, codeHash };
+}
+var processCodeHasher = createCodeHasher();
+function readCodeFile(file) {
+  let text;
+  try {
+    text = fs2.readFileSync(file);
+  } catch {
+    return null;
+  }
+  return {
+    digest: createHash("sha256").update(text).digest("hex"),
+    imports: importsOf(file, text.toString("utf8"))
+  };
+}
+function importsOf(file, text) {
+  const asked = /* @__PURE__ */ new Set();
+  const found = [];
+  for (const match of text.matchAll(IMPORT_FORMS)) {
+    const kind = match[1] === void 0 ? "require" : "import";
+    const specifier = match[1] ?? match[2] ?? "";
+    if (asked.has(`${kind} ${specifier}`)) {
+      continue;
+    }
+    asked.add(`${kind} ${specifier}`);
+    const target = resolveImport(specifier, file, kind);
+    if (target !== null) {
+      found.push(target);
+    }
+  }
+  return found;
+}
+function resolveImport(specifier, fromFile, kind) {
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    return realFile(path4.resolve(path4.dirname(fromFile), specifier));
+  }
+  if (specifier.startsWith(SUSS_SCOPE)) {
+    return resolvePackageImport(specifier, fromFile, kind);
+  }
+  return null;
+}
+function resolvePackageImport(specifier, fromFile, kind) {
+  const [scope = "", name = "", ...rest] = specifier.split("/");
+  const packageName = `${scope}/${name}`;
+  const subpath = rest.length === 0 ? "." : `./${rest.join("/")}`;
+  const lookIn = createRequire(fromFile).resolve.paths(packageName) ?? [];
+  for (const dir of lookIn) {
+    const packageDir = path4.join(dir, packageName);
+    const manifest = readManifest(packageDir);
+    if (manifest === null) {
+      continue;
+    }
+    const target = exportTarget(manifest, subpath, CONDITIONS[kind]);
+    return target === null ? null : realFile(path4.join(packageDir, target));
+  }
+  return null;
+}
+function readManifest(packageDir) {
+  try {
+    return JSON.parse(
+      fs2.readFileSync(path4.join(packageDir, "package.json"), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function exportTarget(manifest, subpath, conditions) {
+  if (manifest.exports === void 0) {
+    return subpath === "." ? manifest.main ?? "index.js" : subpath;
+  }
+  return conditionalTarget(subpathEntry(manifest.exports, subpath), conditions);
+}
+function subpathEntry(exportsField, subpath) {
+  const isSubpathMap = typeof exportsField === "object" && exportsField !== null && !Array.isArray(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."));
+  if (isSubpathMap) {
+    return exportsField[subpath];
+  }
+  return subpath === "." ? exportsField : void 0;
+}
+function conditionalTarget(value, conditions) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const each of value) {
+      const found = conditionalTarget(each, conditions);
+      if (found !== null) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (value === null || typeof value !== "object") {
+    return null;
+  }
+  for (const [condition, target] of Object.entries(value)) {
+    if (!conditions.has(condition)) {
+      continue;
+    }
+    const found = conditionalTarget(target, conditions);
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+}
+function realFile(file) {
+  try {
+    return fs2.realpathSync(file);
+  } catch {
+    return null;
+  }
+}
+
+// src/adapterStamp.ts
 var SOURCE_STAMP = { kind: "source" };
 function createAdapterStamp(config) {
   let cachedCodeStamp = null;
@@ -1369,19 +1778,19 @@ function createAdapterStamp(config) {
 function readAdapterCodeStamp(moduleUrl) {
   try {
     const selfPath = fileURLToPath(moduleUrl);
-    const hash = computeDistHashFrom(path4.dirname(selfPath));
+    const hash = computeDistHashFrom(path5.dirname(selfPath), processCodeHasher);
     return hash.length > 0 ? { kind: "bundle", hash } : SOURCE_STAMP;
   } catch {
     return SOURCE_STAMP;
   }
 }
-function computeDistHashFrom(dir) {
-  const candidates = [path4.join(dir, "index.js"), path4.join(dir, "index.cjs")];
+function computeDistHashFrom(dir, hasher = createCodeHasher()) {
+  const candidates = [path5.join(dir, "index.js"), path5.join(dir, "index.cjs")];
   for (const candidate of candidates) {
-    if (!fs2.existsSync(candidate)) {
+    if (!fs3.existsSync(candidate)) {
       continue;
     }
-    return computeContentHash([candidate, ...analysisBundles()]);
+    return hasher.codeHash(candidate);
   }
   return "";
 }
@@ -1389,10 +1798,10 @@ function computeContentHash(paths) {
   if (paths.length === 0) {
     return "";
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const file of paths) {
     try {
-      hash.update(fs2.readFileSync(file));
+      hash.update(fs3.readFileSync(file));
     } catch {
       return "";
     }
@@ -1403,12 +1812,12 @@ function projectFileStamp(paths) {
   if (paths.length === 0) {
     return "none";
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const file of [...paths].sort()) {
     hash.update(file);
     hash.update("\0");
     try {
-      hash.update(fs2.readFileSync(file));
+      hash.update(fs3.readFileSync(file));
     } catch {
       hash.update("absent");
     }
@@ -1421,8 +1830,9 @@ function extractionConfigStamp(config) {
     ["includeReachable", optionalText(config.includeReachable)],
     ["workspaceRoot", config.workspaceRoot],
     ["projectRoot", config.projectRoot],
-    ["importRoots", config.importRoots?.join(path4.delimiter)],
-    ["modules", modulesStamp(config.modules)]
+    ["importRoots", config.importRoots?.join(path5.delimiter)],
+    ["modules", modulesStamp(config.modules)],
+    ["walkedDirectory", config.walkedDirectory]
   ];
   return parts.flatMap(
     ([name, value]) => value === void 0 ? [] : [`${name}=${value}`]
@@ -1435,26 +1845,288 @@ function runDigest(packsDigest, packs, files) {
   const inputs = packs.flatMap((pack) => pack.discoveryInputs?.(files) ?? []);
   return `${packsDigest}|reads:${projectFileStamp(inputs)}`;
 }
-function analysisBundles() {
-  const require2 = createRequire(import.meta.url);
-  const found = [];
-  for (const name of ANALYSIS_PACKAGES) {
-    try {
-      found.push(require2.resolve(name));
-    } catch {
+
+// src/cache.ts
+import { createHash as createHash5 } from "crypto";
+import fs7 from "fs/promises";
+import path8 from "path";
+import { readJsonFile as readJsonFile3, writeDocumentFile as writeDocumentFile2 } from "@suss/behavioral-ir/files";
+
+// src/cacheIndex.ts
+import { BOUNDARY_ROLE, displayLabel } from "@suss/behavioral-ir";
+import { readJsonFile, writeDocumentFile } from "@suss/behavioral-ir/files";
+function entriesOf(units) {
+  const boundaries = [];
+  const callees = [];
+  units.forEach((summary, unit) => {
+    const seen = /* @__PURE__ */ new Set();
+    const add = (key, role) => {
+      if (key !== null && !seen.has(`${role} ${key}`)) {
+        seen.add(`${role} ${key}`);
+        boundaries.push([key, unit, role]);
+      }
+    };
+    const own = summary.identity?.boundaryBinding ?? null;
+    if (own !== null) {
+      add(
+        keyOf3(own),
+        BOUNDARY_ROLE[summary.kind] === "provider" ? "serves" : "calls"
+      );
+    }
+    const spellings = /* @__PURE__ */ new Set();
+    for (const transition of summary.transitions ?? []) {
+      for (const effect of transition.effects ?? []) {
+        if (effect.type === "interaction") {
+          add(keyOf3(effect.binding), "calls");
+        }
+        if (effect.type === "invocation") {
+          spellings.add(effect.callee);
+        }
+      }
+    }
+    for (const spelling of spellings) {
+      callees.push([spelling, unit]);
+    }
+  });
+  return { boundaries, callees };
+}
+function indexOf(shards) {
+  const boundaries = {};
+  const callees = {};
+  shards.forEach(({ entries }, file) => {
+    for (const [key, unit, role] of entries.boundaries) {
+      listAt(boundaries, key).push([file, unit, role]);
+    }
+    for (const [spelling, unit] of entries.callees) {
+      listAt(callees, spelling).push([file, unit]);
+    }
+  });
+  return {
+    files: shards.map(({ file, id }) => [file, id]),
+    boundaries,
+    callees
+  };
+}
+function listAt(record, key) {
+  const existing = Object.hasOwn(record, key) ? record[key] : void 0;
+  if (existing !== void 0) {
+    return existing;
+  }
+  const created = [];
+  record[key] = created;
+  return created;
+}
+function entriesByShard(index) {
+  const byShard = /* @__PURE__ */ new Map();
+  const at = index.files.map(([, id]) => {
+    const entries = { boundaries: [], callees: [] };
+    byShard.set(id, entries);
+    return entries;
+  });
+  for (const [key, units] of Object.entries(index.boundaries)) {
+    for (const [file, unit, role] of units) {
+      at[file]?.boundaries.push([key, unit, role]);
     }
   }
-  return found;
+  for (const [spelling, units] of Object.entries(index.callees)) {
+    for (const [file, unit] of units) {
+      at[file]?.callees.push([spelling, unit]);
+    }
+  }
+  return byShard;
+}
+function readStoreIndex(file) {
+  try {
+    const index = readJsonFile(file);
+    return Array.isArray(index.files) ? index : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoreIndex(file, index) {
+  writeDocumentFile(file, index);
+}
+function keyOf3(binding) {
+  try {
+    return displayLabel(binding);
+  } catch {
+    return null;
+  }
 }
 
-// src/cache.ts
+// src/cacheShards.ts
 import { createHash as createHash3 } from "crypto";
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs4 from "fs";
+import path6 from "path";
+import {
+  documentPieces,
+  readJsonFile as readJsonFile2,
+  writeFileAtomically
+} from "@suss/behavioral-ir/files";
+var SHARDS_DIR = "shards";
+var RECORDS_DIR = "records";
+var STORED_ID = /^[0-9a-f]{32}\.json$/;
+function writeShard(entryDir, content) {
+  return writeOnce(path6.join(entryDir, SHARDS_DIR), interned(content));
+}
+function readShard(entryDir, id, file) {
+  const stored = readStored(path6.join(entryDir, SHARDS_DIR), id);
+  if (stored?.file !== file || !Array.isArray(stored.units)) {
+    return null;
+  }
+  const take = takerFor(stored.intern ?? []);
+  return {
+    file: stored.file,
+    units: stored.units.map((unit) => expanded(unit, take))
+  };
+}
+function writeRecord(entryDir, meta) {
+  return writeOnce(path6.join(entryDir, RECORDS_DIR), { meta });
+}
+function readRecord(entryDir, id) {
+  const stored = readStored(path6.join(entryDir, RECORDS_DIR), id);
+  return typeof stored === "object" && stored !== null ? stored : null;
+}
+function recordReader(entryDir) {
+  const opened = /* @__PURE__ */ new Map();
+  return (id) => {
+    if (!opened.has(id)) {
+      const record2 = readRecord(entryDir, id);
+      opened.set(id, record2);
+      return record2;
+    }
+    const record = opened.get(id) ?? null;
+    return record === null ? null : copyOfJson(record);
+  };
+}
+function removeStoredOutside(entryDir, keep) {
+  for (const kind of [SHARDS_DIR, RECORDS_DIR]) {
+    const root = path6.join(entryDir, kind);
+    for (const prefix of namesIn(root)) {
+      const dir = path6.join(root, prefix);
+      for (const name of namesIn(dir)) {
+        if (STORED_ID.test(name) && !keep.has(name.slice(0, -".json".length))) {
+          fs4.rmSync(path6.join(dir, name), { force: true });
+        }
+      }
+    }
+  }
+}
+function namesIn(dir) {
+  try {
+    return fs4.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function writeOnce(root, value) {
+  const pieces = [...documentPieces(value)];
+  const hash = createHash3("sha256");
+  for (const piece of pieces) {
+    hash.update(piece);
+  }
+  const id = hash.digest("hex").slice(0, 32);
+  const file = storedPath(root, id);
+  if (!fs4.existsSync(file)) {
+    writeFileAtomically(file, pieces);
+  }
+  return id;
+}
+function readStored(root, id) {
+  try {
+    return readJsonFile2(storedPath(root, id));
+  } catch {
+    return void 0;
+  }
+}
+function storedPath(root, id) {
+  return path6.join(root, id.slice(0, 2), `${id}.json`);
+}
+function interned(content) {
+  const intern = [];
+  const byText = /* @__PURE__ */ new Map();
+  const byObject = /* @__PURE__ */ new Map();
+  const positionOf = (value) => {
+    const known = byObject.get(value);
+    if (known !== void 0) {
+      return known;
+    }
+    const text = JSON.stringify(value) ?? "null";
+    let position = byText.get(text);
+    if (position === void 0) {
+      position = intern.length;
+      intern.push(value);
+      byText.set(text, position);
+    }
+    if (typeof value === "object" && value !== null) {
+      byObject.set(value, position);
+    }
+    return position;
+  };
+  const positions = (values) => Array.isArray(values) ? values.map(positionOf) : values;
+  const units = content.units.map((summary) => ({
+    ...summary,
+    transitions: summary.transitions.map((transition) => ({
+      ...transition,
+      conditions: positions(transition.conditions),
+      effects: positions(transition.effects)
+    })),
+    gaps: summary.gaps.map((gap) => ({
+      ...gap,
+      conditions: positions(gap.conditions)
+    }))
+  }));
+  return {
+    file: content.file,
+    intern,
+    units
+  };
+}
+function expanded(unit, take) {
+  const values = (positions) => Array.isArray(positions) ? positions.map((at) => take(at)) : positions;
+  const transitions = Array.isArray(unit.transitions) ? unit.transitions : [];
+  const gaps = Array.isArray(unit.gaps) ? unit.gaps : [];
+  return {
+    ...unit,
+    transitions: transitions.map((transition) => ({
+      ...transition,
+      conditions: values(transition.conditions),
+      effects: values(transition.effects)
+    })),
+    gaps: gaps.map((gap) => ({
+      ...gap,
+      conditions: values(gap.conditions)
+    }))
+  };
+}
+function takerFor(intern) {
+  const handedOut = /* @__PURE__ */ new Set();
+  return (position) => {
+    const value = intern[position];
+    if (!handedOut.has(position)) {
+      handedOut.add(position);
+      return value;
+    }
+    return copyOfJson(value);
+  };
+}
+function copyOfJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(copyOfJson);
+  }
+  if (typeof value === "object" && value !== null) {
+    const copy = {};
+    for (const key of Object.keys(value)) {
+      copy[key] = copyOfJson(value[key]);
+    }
+    return copy;
+  }
+  return value;
+}
 
 // src/cacheStamps.ts
-import { createHash as createHash2 } from "crypto";
-import fs3 from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import fs5 from "fs/promises";
 var RECENT_CHANGE_MS = 2e3;
 function stampMayMissAWrite(stat, statAt) {
   return Math.max(stat.mtimeMs, stat.ctimeMs) > statAt - RECENT_CHANGE_MS;
@@ -1475,7 +2147,7 @@ async function startRun(files, configPath) {
 }
 async function statAtStart(filePath) {
   try {
-    const stat = await fs3.stat(filePath);
+    const stat = await fs5.stat(filePath);
     return {
       stamp: { path: filePath, mtimeMs: stat.mtimeMs, size: stat.size },
       ctimeMs: stat.ctimeMs
@@ -1525,7 +2197,7 @@ async function recordedStamp(start, run, prior) {
     return start.stamp;
   }
   const filePath = start.stamp.path;
-  const now = await fs3.stat(filePath).catch(() => null);
+  const now = await fs5.stat(filePath).catch(() => null);
   if (now === null || now.mtimeMs !== start.stamp.mtimeMs || now.size !== start.stamp.size || now.ctimeMs !== start.ctimeMs) {
     return null;
   }
@@ -1542,8 +2214,8 @@ function reusableHash(prior, stamp) {
 }
 async function hashFile(filePath) {
   try {
-    const content = await fs3.readFile(filePath);
-    return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+    const content = await fs5.readFile(filePath);
+    return createHash4("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return null;
   }
@@ -1558,11 +2230,30 @@ function fileStampEquals(a, b) {
   return a.path === b.path && a.mtimeMs === b.mtimeMs && a.size === b.size;
 }
 
+// src/ignoredDirectory.ts
+import fs6 from "fs";
+import path7 from "path";
+function makeIgnoredDirectory(dir) {
+  fs6.mkdirSync(dir, { recursive: true });
+  const ignore = path7.join(dir, ".gitignore");
+  if (!fs6.existsSync(ignore)) {
+    fs6.writeFileSync(ignore, "*\n");
+  }
+}
+
 // src/cache.ts
-var SCHEMA_VERSION = "9";
+var SCHEMA_VERSION = "10";
+var MANIFEST = "manifest.json";
+var INDEX = "index.json";
 var MAX_ENTRIES = 2;
 var ENTRY_PREFIX = "key-";
 var ENTRY_DIR_NAME = new RegExp(`^${ENTRY_PREFIX}[0-9a-f]{16}$`);
+function ownersWhereWritten(summaries, walkedFileOf) {
+  return summaries.map((summary) => {
+    const walked = walkedFileOf(summary.location.file);
+    return walked === void 0 ? [] : [walked];
+  });
+}
 function createCacheLayer(cacheDir) {
   if (cacheDir === null) {
     return {
@@ -1582,7 +2273,7 @@ function createCacheLayer(cacheDir) {
   const lookupWith = async (input, run) => {
     const entryDir = entryDirFor(cacheDir, input);
     const manifest = await manifests.readAtRunStart(
-      path5.join(entryDir, "manifest.json")
+      path8.join(entryDir, MANIFEST)
     );
     if (manifest === null) {
       return missDiag(await describeAbsentEntry(cacheDir));
@@ -1597,11 +2288,15 @@ function createCacheLayer(cacheDir) {
     if (!await filesStillMatch(manifest.files, run)) {
       return missDiag("files-changed");
     }
+    const summaries = storedSummaries(entryDir, manifest);
+    if (summaries === null) {
+      return missDiag("no-manifest");
+    }
     await markUsed(entryDir);
     manifests.forget();
     return {
       kind: "hit",
-      summaries: manifest.summaries,
+      summaries,
       diagnostic: { kind: "hit" }
     };
   };
@@ -1621,10 +2316,8 @@ function createCacheLayer(cacheDir) {
     },
     async plan(input) {
       const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await manifests.readAgain(
-        path5.join(entryDir, "manifest.json")
-      );
-      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0 || manifest.owners === void 0) {
+      const manifest = await manifests.readAgain(path8.join(entryDir, MANIFEST));
+      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0) {
         return null;
       }
       const run = await runFor(input);
@@ -1635,14 +2328,17 @@ function createCacheLayer(cacheDir) {
       )) {
         return null;
       }
+      const summaries = storedSummaries(entryDir, manifest);
+      const records = storedRecords(entryDir, manifest);
+      if (summaries === null || records === null) {
+        return null;
+      }
       await markUsed(entryDir);
-      return buildPlan(manifest, run);
+      return buildPlan(manifest, records, summaries, run);
     },
     async write(input, summaries, attribution) {
       const entryDir = entryDirFor(cacheDir, input);
-      const previous = await manifests.readAgain(
-        path5.join(entryDir, "manifest.json")
-      );
+      const previous = await manifests.readAgain(path8.join(entryDir, MANIFEST));
       manifests.forget();
       const known = runs.get(input);
       const run = known ?? await runFor(input);
@@ -1658,58 +2354,119 @@ function createCacheLayer(cacheDir) {
         )
       );
       const files = recorded.filter((stamp) => stamp !== null);
+      const encoded = attribution === void 0 ? null : encodeAttribution(
+        attribution,
+        (meta) => writeRecord(entryDir, meta)
+      );
+      makeIgnoredDirectory(cacheDir);
+      const shards = writeShards(entryDir, summaries, encoded);
       const manifest = {
         schemaVersion: SCHEMA_VERSION,
         adapterPacksDigest: input.adapterPacksDigest,
         configStamp,
         files,
-        summaries,
-        ...attribution === void 0 ? {} : encodeAttribution(attribution)
+        summaryCount: summaries.length,
+        shards,
+        ...encoded === null ? {} : encoded.stored
       };
-      await fs4.mkdir(entryDir, { recursive: true });
-      await fs4.writeFile(
-        path5.join(entryDir, "manifest.json"),
-        JSON.stringify(manifest)
+      writeDocumentFile2(path8.join(entryDir, MANIFEST), manifest);
+      removeStoredOutside(
+        entryDir,
+        /* @__PURE__ */ new Set([...storedIds(manifest), ...storedIds(previous)])
       );
       await evictOldEntries(cacheDir, entryDir);
     }
   };
 }
-async function buildPlan(manifest, run) {
-  const stored = new Map(manifest.files.map((f) => [f.path, f]));
-  const current = new Map(run.files.map((f) => [f.stamp.path, f.stamp]));
-  const changed = /* @__PURE__ */ new Set();
-  const added = /* @__PURE__ */ new Set();
-  const removed = /* @__PURE__ */ new Set();
-  for (const p of stored.keys()) {
-    if (!current.has(p)) {
-      removed.add(p);
+function storedIds(manifest) {
+  return [
+    ...(manifest?.shards ?? []).map((shard) => shard.id),
+    ...(manifest?.rootMeta ?? []).flatMap(
+      (root) => root.record === void 0 ? [] : [root.record]
+    )
+  ];
+}
+function writeShards(entryDir, summaries, encoded) {
+  const byFile = /* @__PURE__ */ new Map();
+  summaries.forEach((summary, position) => {
+    const file = summary.location?.file ?? "";
+    const shard = byFile.get(file) ?? {
+      content: { file, units: [] },
+      order: [],
+      owners: []
+    };
+    byFile.set(file, shard);
+    shard.content.units.push(summary);
+    shard.order.push(position);
+    shard.owners.push(encoded?.owners[position] ?? []);
+  });
+  const indexFile = path8.join(entryDir, INDEX);
+  const before = readStoreIndex(indexFile);
+  const known = before === null ? /* @__PURE__ */ new Map() : entriesByShard(before);
+  const sorted = [...byFile].sort(([a], [b]) => a < b ? -1 : 1);
+  const written = sorted.map(([file, { content, order, owners }]) => {
+    const id = writeShard(entryDir, content);
+    return {
+      shard: {
+        file,
+        id,
+        order,
+        ...encoded === null ? {} : { owners }
+      },
+      entries: known.get(id) ?? entriesOf(content.units)
+    };
+  });
+  writeStoreIndex(
+    indexFile,
+    indexOf(
+      written.map(({ shard, entries }) => ({
+        file: shard.file,
+        id: shard.id,
+        entries
+      }))
+    )
+  );
+  return written.map(({ shard }) => shard);
+}
+function storedSummaries(entryDir, manifest) {
+  const summaries = new Array(
+    manifest.summaryCount
+  );
+  for (const shard of manifest.shards) {
+    const content = readShard(entryDir, shard.id, shard.file);
+    if (content === null || content.units.length !== shard.order.length) {
+      return null;
     }
+    shard.order.forEach((position, i) => {
+      summaries[position] = content.units[i];
+    });
   }
-  const toVerify = [];
-  for (const [p, stamp] of current) {
-    const before = stored.get(p);
-    if (before === void 0) {
-      changed.add(p);
-      added.add(p);
-    } else if (!fileStampEquals(before, stamp)) {
-      if (before.contentHash === void 0) {
-        changed.add(p);
-      } else {
-        toVerify.push(p);
-      }
-    } else if (before.verifyHash === true) {
-      toVerify.push(p);
+  for (let position = 0; position < summaries.length; position++) {
+    if (summaries[position] === void 0) {
+      return null;
     }
   }
-  await Promise.all(
-    toVerify.map(async (p) => {
-      const hash = await hashOf(run, p);
-      if (hash === null || hash !== stored.get(p)?.contentHash) {
-        changed.add(p);
-      }
-    })
-  );
+  return summaries;
+}
+function storedRecords(entryDir, manifest) {
+  const records = /* @__PURE__ */ new Map();
+  const roots = manifest.roots ?? [];
+  const readRecord2 = recordReader(entryDir);
+  for (const [i, root] of (manifest.rootMeta ?? []).entries()) {
+    const rootPath = roots[i];
+    if (rootPath === void 0 || root.record === void 0) {
+      continue;
+    }
+    const record = readRecord2(root.record);
+    if (record === null) {
+      return null;
+    }
+    records.set(rootPath, record.meta);
+  }
+  return records;
+}
+async function buildPlan(manifest, records, stored, run) {
+  const { changed, added, removed } = await changedSince(manifest, run);
   const roots = /* @__PURE__ */ new Map();
   const rootNames = manifest.roots ?? [];
   const depPaths = manifest.depPaths ?? [];
@@ -1719,23 +2476,24 @@ async function buildPlan(manifest, run) {
   });
   let rootsDeclined = 0;
   rootNames.forEach((rootPath, i) => {
-    const meta = manifest.rootMeta?.[i];
-    if (meta === void 0) {
+    const record = manifest.rootMeta?.[i];
+    if (record === void 0) {
       return;
     }
-    if (!meta.cacheable) {
+    if (!record.cacheable) {
       rootsDeclined += 1;
     }
     roots.set(rootPath, {
       path: rootPath,
-      cacheable: meta.cacheable,
-      deps: pathsOf(meta.deps),
-      claims: meta.claims,
-      meta: meta.meta,
-      packs: meta.packs,
-      ...meta.imports === void 0 ? {} : { imports: pathsOf(meta.imports) }
+      cacheable: record.cacheable,
+      deps: pathsOf(record.deps),
+      claims: record.claims,
+      meta: records.get(rootPath),
+      packs: record.packs,
+      ...record.imports === void 0 ? {} : { imports: pathsOf(record.imports) }
     });
   });
+  const current = new Set(run.files.map((f) => f.stamp.path));
   const unchanged = (filePath, deps) => current.has(filePath) && !changed.has(filePath) && !deps.some((d) => changed.has(d) || removed.has(d));
   const validRoots = /* @__PURE__ */ new Set();
   for (const [rootPath, record] of roots) {
@@ -1743,14 +2501,14 @@ async function buildPlan(manifest, run) {
       validRoots.add(rootPath);
     }
   }
-  const units = (manifest.units ?? []).flatMap((stored2) => {
-    const file = depPaths[stored2.file];
+  const units = (manifest.units ?? []).flatMap((unit) => {
+    const file = depPaths[unit.file];
     return file === void 0 ? [] : [
       {
-        key: stored2.key,
+        key: unit.key,
         file,
-        deps: pathsOf(stored2.deps),
-        data: stored2.data
+        deps: pathsOf(unit.deps),
+        data: unit.data
       }
     ];
   });
@@ -1768,7 +2526,7 @@ async function buildPlan(manifest, run) {
       }
     }
   }
-  const owners = manifest.owners ?? [];
+  const ownerPaths = ownersInRunOrder(manifest);
   return {
     changed,
     removed,
@@ -1780,36 +2538,81 @@ async function buildPlan(manifest, run) {
     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))) {
+      stored.forEach((summary, i) => {
+        const owners = ownerPaths[i] ?? [];
+        if (owners.some((p) => valid.has(p))) {
           summaries.push(summary);
-          reusedOwners.push(ownerPaths.filter((p) => valid.has(p)));
+          reusedOwners.push(owners.filter((p) => valid.has(p)));
         }
       });
       return { summaries, owners: reusedOwners };
     },
     allSummaries() {
-      return manifest.summaries;
+      return stored;
     },
     attribution() {
       return {
         roots: [...roots.values()],
-        owners: owners.map(
-          (ownerIds) => ownerIds.flatMap((o) => {
-            const p = rootNames[o];
-            return p === void 0 ? [] : [p];
-          })
-        ),
+        owners: ownerPaths,
         units
       };
     }
   };
 }
-function encodeAttribution(attribution) {
+function ownersInRunOrder(manifest) {
+  const rootNames = manifest.roots ?? [];
+  const owners = Array.from(
+    { length: manifest.summaryCount },
+    () => []
+  );
+  for (const shard of manifest.shards ?? []) {
+    shard.order.forEach((position, i) => {
+      owners[position] = (shard.owners?.[i] ?? []).flatMap((o) => {
+        const p = rootNames[o];
+        return p === void 0 ? [] : [p];
+      });
+    });
+  }
+  return owners;
+}
+async function changedSince(manifest, run) {
+  const stored = new Map(manifest.files.map((f) => [f.path, f]));
+  const current = new Map(run.files.map((f) => [f.stamp.path, f.stamp]));
+  const changed = /* @__PURE__ */ new Set();
+  const added = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  for (const p of stored.keys()) {
+    if (!current.has(p)) {
+      removed.add(p);
+    }
+  }
+  const toVerify = [];
+  for (const [p, stamp] of current) {
+    const before = stored.get(p);
+    if (before === void 0) {
+      changed.add(p);
+      added.add(p);
+    } else if (!fileStampEquals(before, stamp)) {
+      if (before.contentHash === void 0) {
+        changed.add(p);
+      } else {
+        toVerify.push(p);
+      }
+    } else if (before.verifyHash === true) {
+      toVerify.push(p);
+    }
+  }
+  await Promise.all(
+    toVerify.map(async (p) => {
+      const hash = await hashOf(run, p);
+      if (hash === null || hash !== stored.get(p)?.contentHash) {
+        changed.add(p);
+      }
+    })
+  );
+  return { changed, added, removed };
+}
+function encodeAttribution(attribution, storeRecord) {
   const roots = attribution.roots.map((r) => r.path);
   const rootIndex = new Map(roots.map((p, i) => [p, i]));
   const depIndex = /* @__PURE__ */ new Map();
@@ -1825,10 +2628,10 @@ function encodeAttribution(attribution) {
     return id;
   };
   const rootMeta = attribution.roots.map((r) => ({
+    ...r.meta === void 0 ? {} : { record: storeRecord(r.meta) },
     cacheable: r.cacheable,
     deps: r.deps.map(depIdOf),
     claims: r.claims,
-    meta: r.meta,
     packs: r.packs,
     ...r.imports === void 0 ? {} : { imports: r.imports.map(depIdOf) }
   }));
@@ -1845,16 +2648,18 @@ function encodeAttribution(attribution) {
     data: unit.data
   }));
   return {
-    roots,
-    rootMeta,
-    depPaths,
-    owners,
-    ...units === void 0 ? {} : { units }
+    stored: {
+      roots,
+      rootMeta,
+      depPaths,
+      ...units === void 0 ? {} : { units }
+    },
+    owners
   };
 }
 async function describeAbsentEntry(cacheDir) {
   try {
-    const entries = await fs4.readdir(cacheDir, { withFileTypes: true });
+    const entries = await fs7.readdir(cacheDir, { withFileTypes: true });
     return entries.some((e) => e.isDirectory() && isEntryDir(e.name)) ? "key-changed" : "no-manifest";
   } catch {
     return "no-manifest";
@@ -1866,8 +2671,8 @@ function entryDirFor(cacheDir, input) {
     input.adapterPacksDigest,
     input.configPath ?? ""
   ].join(" ");
-  const name = createHash3("sha256").update(key).digest("hex").slice(0, 16);
-  return path5.join(cacheDir, `${ENTRY_PREFIX}${name}`);
+  const name = createHash5("sha256").update(key).digest("hex").slice(0, 16);
+  return path8.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
 function isEntryDir(name) {
   return ENTRY_DIR_NAME.test(name);
@@ -1875,24 +2680,24 @@ function isEntryDir(name) {
 async function markUsed(entryDir) {
   const now = /* @__PURE__ */ new Date();
   try {
-    await fs4.utimes(entryDir, now, now);
+    await fs7.utimes(entryDir, now, now);
   } catch {
   }
 }
 async function evictOldEntries(cacheDir, keepDir) {
   try {
-    await fs4.rm(path5.join(cacheDir, "manifest.json"), { force: true });
-    const entries = await fs4.readdir(cacheDir, { withFileTypes: true });
+    await fs7.rm(path8.join(cacheDir, "manifest.json"), { force: true });
+    const entries = await fs7.readdir(cacheDir, { withFileTypes: true });
     const dirs = await Promise.all(
       entries.filter((e) => e.isDirectory() && isEntryDir(e.name)).map(async (e) => {
-        const dir = path5.join(cacheDir, e.name);
-        const stat = await fs4.stat(dir);
+        const dir = path8.join(cacheDir, e.name);
+        const stat = await fs7.stat(dir);
         return { dir, mtimeMs: stat.mtimeMs };
       })
     );
     const doomed = dirs.filter((d) => d.dir !== keepDir).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(MAX_ENTRIES - 1);
     await Promise.all(
-      doomed.map((d) => fs4.rm(d.dir, { recursive: true, force: true }))
+      doomed.map((d) => fs7.rm(d.dir, { recursive: true, force: true }))
     );
   } catch {
   }
@@ -1907,7 +2712,7 @@ var ManifestReads = class {
   last = null;
   async readAtRunStart(manifestPath) {
     const stamp = await manifestStamp(manifestPath);
-    const manifest = await readManifest(manifestPath);
+    const manifest = await readManifest2(manifestPath);
     this.last = { path: manifestPath, stamp, manifest };
     return manifest;
   }
@@ -1924,23 +2729,60 @@ var ManifestReads = class {
 };
 async function manifestStamp(manifestPath) {
   try {
-    const stat = await fs4.stat(manifestPath);
+    const stat = await fs7.stat(manifestPath);
     return `${stat.ino}:${stat.mtimeMs}:${stat.size}`;
   } catch {
     return null;
   }
 }
-async function readManifest(manifestPath) {
+async function readManifest2(manifestPath) {
   try {
-    const raw = await fs4.readFile(manifestPath, "utf-8");
-    return JSON.parse(raw);
+    const manifest = readJsonFile3(manifestPath);
+    return Array.isArray(manifest.shards) ? manifest : null;
   } catch {
     return null;
   }
 }
 
+// src/cacheLocation.ts
+import { createHash as createHash6 } from "crypto";
+import fs8 from "fs";
+import path9 from "path";
+var CACHE_DIR_ENV = "SUSS_CACHE_DIR";
+function chosenCacheRoot() {
+  const chosen = process.env[CACHE_DIR_ENV];
+  if (chosen === void 0 || chosen === "") {
+    return null;
+  }
+  return path9.resolve(chosen);
+}
+function realPathOrSelf(dir) {
+  try {
+    return fs8.realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+function projectKey(projectDir) {
+  return createHash6("sha256").update(realPathOrSelf(path9.resolve(projectDir))).digest("hex").slice(0, 16);
+}
+function extractionCacheDirFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return path9.join(projectDir, ".suss", "cache");
+  }
+  return path9.join(root, "cache", projectKey(projectDir));
+}
+function liveRecordFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return path9.join(projectDir, ".suss", "live", "server.json");
+  }
+  return path9.join(root, "live", `${projectKey(projectDir)}.json`);
+}
+
 // src/extractionReport.ts
-import { BOUNDARY_ROLE } from "@suss/behavioral-ir";
+import { BOUNDARY_ROLE as BOUNDARY_ROLE2 } from "@suss/behavioral-ir";
 var emptyTally = () => ({
   candidateFiles: 0,
   unitsDiscovered: 0,
@@ -1990,7 +2832,7 @@ function summaryCountsByPack(summaries) {
     }
     const entry = counts.get(recognition) ?? emptyCounts();
     entry.bound += 1;
-    if (BOUNDARY_ROLE[summary.kind] === "provider") {
+    if (BOUNDARY_ROLE2[summary.kind] === "provider") {
       entry.providers += 1;
     }
     if (summary.transitions.length > 0) {
@@ -2215,6 +3057,17 @@ function undocumentedDeclarations(gradients) {
     detail: gradient.withoutExample.join(", ")
   }));
 }
+function packConfigCheck(needs) {
+  return {
+    name: "every pack that needs an option was given it",
+    code: "no-config",
+    audience: "run",
+    violations: needs.map((need) => ({
+      label: need.pack,
+      detail: `reads nothing until ${need.option} is set, for example ${need.example}. Write that to a JSON file and pass -f ${need.pack}=<config.json>.`
+    }))
+  };
+}
 function evaluatePackHealth(report) {
   const gradients = packGradients(report);
   return [
@@ -2367,7 +3220,7 @@ function makeTransitionId(functionName, branch) {
   const { terminal } = branch;
   const statusKey = terminal.statusCode === null ? "none" : terminal.statusCode.type === "literal" ? String(terminal.statusCode.value) : `dyn:${terminal.statusCode.sourceText}`;
   const conditionSig = branch.conditions.map((c) => `${c.polarity}:${c.sourceText}`).join(";");
-  const conditionHash = createHash4("sha1").update(conditionSig).digest("hex").slice(0, 7);
+  const conditionHash = createHash7("sha1").update(conditionSig).digest("hex").slice(0, 7);
   return `${functionName}:${terminal.kind}:${statusKey}:${conditionHash}`;
 }
 function collapseReading(table, reading) {
@@ -2426,6 +3279,7 @@ function unreadSentences(raw) {
     ...raw.branches.flatMap(readingsOfBranch)
   ];
   return [
+    ...raw.readFailure !== void 0 ? [raw.readFailure] : [],
     ...raw.unreadBinding !== void 0 ? [raw.unreadBinding] : [],
     ...handedOver.map(unreadReasonOf).filter((reason) => reason !== null)
   ];
@@ -2588,6 +3442,12 @@ function buildHttpMetadataValue(raw) {
   if (raw.failureDelivery !== void 0) {
     http.failureDelivery = raw.failureDelivery;
   }
+  if (raw.redirectDelivery !== void 0) {
+    http.redirectDelivery = raw.redirectDelivery;
+  }
+  if (raw.declaredStatuses !== void 0 && raw.declaredStatuses.length > 0) {
+    http.declaredStatuses = raw.declaredStatuses;
+  }
   return Object.keys(http).length > 0 ? http : null;
 }
 function buildGraphqlMetadataValue(raw) {
@@ -2655,13 +3515,16 @@ function detectGaps(raw, transitions, options) {
   return gaps;
 }
 function bodyWentUnread(raw) {
+  if (raw.readFailure !== void 0) {
+    return true;
+  }
   if (raw.bodyContent === "absent" || raw.bodyContent === "elsewhere") {
     return true;
   }
   return raw.bodyContent === "statements" && raw.branches.length === 0;
 }
 function describeUnreadBody(raw) {
-  if (!bodyWentUnread(raw)) {
+  if (!bodyWentUnread(raw) || raw.readFailure !== void 0) {
     return null;
   }
   if (raw.bodyContent === "absent") {
@@ -2733,10 +3596,16 @@ var terminalConverters = {
         headers: {}
       };
     }
+    const ancestry = t.exceptionAncestry;
     return {
       type: "throw",
       exceptionType: t.exceptionType,
-      message: t.message
+      message: t.message,
+      ...ancestry === void 0 ? {} : {
+        exceptionAncestors: ancestry.ancestors,
+        ...ancestry.incomplete ? { ancestryIncomplete: true } : {}
+      },
+      ...t.statusWhenUncaught === void 0 ? {} : { statusWhenUncaught: t.statusWhenUncaught }
     };
   },
   render: (t) => ({
@@ -2805,11 +3674,13 @@ function paramToInput(param) {
   };
 }
 export {
+  CACHE_DIR_ENV,
   EnclosingNodes,
   IdMap,
   IdSet,
   KeptParses,
   MAX_ENTRIES,
+  MAX_HELPER_PATHS,
   MAX_PATHS,
   MODULE_SURFACE_RECOGNITION,
   PathBudgetExceeded,
@@ -2821,6 +3692,7 @@ export {
   assembleSummary,
   assessConfidence,
   buildUngatedExtractionReport,
+  chosenCacheRoot,
   commonDirectoryOf,
   composeWrappers,
   computeContentHash,
@@ -2828,6 +3700,7 @@ export {
   configuredCallOption,
   createAdapterStamp,
   createCacheLayer,
+  createCodeHasher,
   createPackTallies,
   createTimer,
   detectGaps,
@@ -2836,24 +3709,33 @@ export {
   enumerateOrDegrade,
   enumerateStructuredPaths,
   evaluatePackHealth,
+  extractionCacheDirFor,
   extractionConfigStamp,
   firstWrittenReading,
   formatPackHealth,
   guardsHoldOn,
+  helperPathsOnVariables,
   httpRouteDiscovery,
   isListedTestFile,
+  liveRecordFor,
+  makeIgnoredDirectory,
   makeTransitionId,
   mapReading,
   markReturnsAsExitCode,
   matchesTestFileName,
+  mergeReadShapes,
   moduleInitStructure,
   moduleOfFile,
   noopTimer,
+  ownersWhereWritten,
+  packConfigCheck,
   packGradients,
   paramToInput,
+  processCodeHasher,
   projectFileStamp,
   rawConditionToPredicate,
   recordPackFailure,
+  redirectDeliveryWhenSet,
   registrationHelperDiscovery,
   routeHelperIndex,
   runDigest,
@@ -2862,6 +3744,7 @@ export {
   settleModules,
   sharedGatingConditions,
   sourceRefsOf,
+  splitAtHandOffs,
   stampMayMissAWrite,
   stampModuleImports,
   stampModules,
@@ -2869,6 +3752,7 @@ export {
   summaryCountsByPack,
   tallyUnit,
   terminalToOutput,
+  throughHelper,
   unreadableReading,
   unwrapJsonStringify,
   valueToReadFurtherFrom,