@suss/extractor 0.34.0 → 0.35.0

package/dist/index.cjs

@@ -30,11 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CACHE_DIR_ENV: () => CACHE_DIR_ENV,
   EnclosingNodes: () => EnclosingNodes,
   IdMap: () => IdMap,
   IdSet: () => IdSet,
   KeptParses: () => KeptParses,
   MAX_ENTRIES: () => MAX_ENTRIES,
+  MAX_HELPER_PATHS: () => MAX_HELPER_PATHS,
   MAX_PATHS: () => MAX_PATHS,
   MODULE_SURFACE_RECOGNITION: () => MODULE_SURFACE_RECOGNITION,
   PathBudgetExceeded: () => PathBudgetExceeded,
@@ -46,6 +48,7 @@ __export(index_exports, {
   assembleSummary: () => assembleSummary,
   assessConfidence: () => assessConfidence,
   buildUngatedExtractionReport: () => buildUngatedExtractionReport,
+  chosenCacheRoot: () => chosenCacheRoot,
   commonDirectoryOf: () => commonDirectoryOf,
   composeWrappers: () => composeWrappers,
   computeContentHash: () => computeContentHash,
@@ -53,6 +56,7 @@ __export(index_exports, {
   configuredCallOption: () => configuredCallOption,
   createAdapterStamp: () => createAdapterStamp,
   createCacheLayer: () => createCacheLayer,
+  createCodeHasher: () => createCodeHasher,
   createPackTallies: () => createPackTallies,
   createTimer: () => createTimer,
   detectGaps: () => detectGaps,
@@ -61,24 +65,33 @@ __export(index_exports, {
   enumerateOrDegrade: () => enumerateOrDegrade,
   enumerateStructuredPaths: () => enumerateStructuredPaths,
   evaluatePackHealth: () => evaluatePackHealth,
+  extractionCacheDirFor: () => extractionCacheDirFor,
   extractionConfigStamp: () => extractionConfigStamp,
   firstWrittenReading: () => firstWrittenReading,
   formatPackHealth: () => formatPackHealth,
   guardsHoldOn: () => guardsHoldOn,
+  helperPathsOnVariables: () => helperPathsOnVariables,
   httpRouteDiscovery: () => httpRouteDiscovery,
   isListedTestFile: () => isListedTestFile,
+  liveRecordFor: () => liveRecordFor,
+  makeIgnoredDirectory: () => makeIgnoredDirectory,
   makeTransitionId: () => makeTransitionId,
   mapReading: () => mapReading,
   markReturnsAsExitCode: () => markReturnsAsExitCode,
   matchesTestFileName: () => matchesTestFileName,
+  mergeReadShapes: () => mergeReadShapes,
   moduleInitStructure: () => moduleInitStructure,
   moduleOfFile: () => moduleOfFile,
   noopTimer: () => noopTimer,
+  ownersWhereWritten: () => ownersWhereWritten,
+  packConfigCheck: () => packConfigCheck,
   packGradients: () => packGradients,
   paramToInput: () => paramToInput,
+  processCodeHasher: () => processCodeHasher,
   projectFileStamp: () => projectFileStamp,
   rawConditionToPredicate: () => rawConditionToPredicate,
   recordPackFailure: () => recordPackFailure,
+  redirectDeliveryWhenSet: () => redirectDeliveryWhenSet,
   registrationHelperDiscovery: () => registrationHelperDiscovery,
   routeHelperIndex: () => routeHelperIndex,
   runDigest: () => runDigest,
@@ -87,6 +100,7 @@ __export(index_exports, {
   settleModules: () => settleModules,
   sharedGatingConditions: () => sharedGatingConditions,
   sourceRefsOf: () => sourceRefsOf,
+  splitAtHandOffs: () => splitAtHandOffs,
   stampMayMissAWrite: () => stampMayMissAWrite,
   stampModuleImports: () => stampModuleImports,
   stampModules: () => stampModules,
@@ -94,6 +108,7 @@ __export(index_exports, {
   summaryCountsByPack: () => summaryCountsByPack,
   tallyUnit: () => tallyUnit,
   terminalToOutput: () => terminalToOutput,
+  throughHelper: () => throughHelper,
   unreadableReading: () => unreadableReading,
   unwrapJsonStringify: () => unwrapJsonStringify,
   valueToReadFurtherFrom: () => valueToReadFurtherFrom,
@@ -102,8 +117,8 @@ __export(index_exports, {
   writtenReading: () => writtenReading
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_crypto4 = require("crypto");
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_node_crypto7 = require("crypto");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
 
 // src/contractStatusGaps.ts
 var import_behavioral_ir = require("@suss/behavioral-ir");
@@ -282,29 +297,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: (0, import_behavioral_ir2.withWrapperMetadata)(transition.metadata, {
+      ...(0, import_behavioral_ir2.readWrapperMetadata)(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(
@@ -316,11 +384,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 = (0, import_behavioral_ir2.readHttpMetadata)(summary)?.declaredContract;
   const binding = summary.identity.boundaryBinding;
@@ -351,10 +499,13 @@ function coversUnit(reference, summary) {
   const binding = summary.identity.boundaryBinding;
   return binding !== null && (0, import_behavioral_ir2.withinScope)(binding, reference.scope);
 }
-function attribute(transitions, reference) {
+function attribute(transitions, reference, catchUncertain = false) {
   return transitions.map((transition) => ({
     ...transition,
-    metadata: (0, import_behavioral_ir2.withWrapperMetadata)(transition.metadata, { from: reference })
+    metadata: (0, import_behavioral_ir2.withWrapperMetadata)(transition.metadata, {
+      from: reference,
+      ...catchUncertain ? { catchUncertain } : {}
+    })
   }));
 }
 function withDistinctIds(transitions) {
@@ -467,13 +618,111 @@ function markExitCodeFrom(summary, marked) {
   summary.metadata = left;
 }
 
+// src/helperHandOff.ts
+var import_behavioral_ir4 = require("@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 && (0, import_behavioral_ir4.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 (0, import_behavioral_ir4.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()
@@ -720,7 +969,7 @@ var configuredCallOption = import_zod.z.object({
 }).strict();
 
 // src/paths/enumeratePaths.ts
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
 var MAX_PATHS = 256;
 var UnmodeledFlow = class extends Error {
 };
@@ -764,12 +1013,12 @@ var loopCompletedCond = (headerText, exit) => fixedCond(
   exit === "throw" ? "earlyThrow" : "earlyReturn"
 );
 var catchEntryCond = () => fixedCond(
-  { sourceText: import_behavioral_ir4.CATCH_ENTRY_TEXT, expression: null },
+  { sourceText: import_behavioral_ir5.CATCH_ENTRY_TEXT, expression: null },
   "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;
     }
@@ -834,9 +1083,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);
@@ -847,15 +1103,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,
@@ -872,7 +1128,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;
@@ -882,7 +1138,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) {
@@ -899,24 +1155,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)
@@ -926,22 +1182,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,
@@ -951,22 +1207,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)) {
@@ -983,7 +1240,7 @@ function stepStatement(ctx, stmt, path6) {
     )
   );
 }
-function soleDisagreement(left, right) {
+function soleDisagreement(left, right, keepsArms) {
   if (left.length !== right.length) {
     return null;
   }
@@ -1002,9 +1259,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 = [];
@@ -1019,7 +1277,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;
         }
@@ -1045,21 +1307,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) => {
@@ -1093,13 +1352,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 };
 }
@@ -1142,8 +1402,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);
@@ -1251,15 +1511,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);
     }
   }
 }
@@ -1338,6 +1595,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) {
@@ -1407,18 +1669,179 @@ function quoted(text, key) {
 }
 
 // src/adapterStamp.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/codeHash.ts
 var import_node_crypto = require("crypto");
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_module = require("module");
 var import_node_path4 = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_meta = {};
-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 = (0, import_node_crypto.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 = import_node_fs2.default.readFileSync(file);
+  } catch {
+    return null;
+  }
+  return {
+    digest: (0, import_node_crypto.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(import_node_path4.default.resolve(import_node_path4.default.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 = (0, import_node_module.createRequire)(fromFile).resolve.paths(packageName) ?? [];
+  for (const dir of lookIn) {
+    const packageDir = import_node_path4.default.join(dir, packageName);
+    const manifest = readManifest(packageDir);
+    if (manifest === null) {
+      continue;
+    }
+    const target = exportTarget(manifest, subpath, CONDITIONS[kind]);
+    return target === null ? null : realFile(import_node_path4.default.join(packageDir, target));
+  }
+  return null;
+}
+function readManifest(packageDir) {
+  try {
+    return JSON.parse(
+      import_node_fs2.default.readFileSync(import_node_path4.default.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 import_node_fs2.default.realpathSync(file);
+  } catch {
+    return null;
+  }
+}
+
+// src/adapterStamp.ts
 var SOURCE_STAMP = { kind: "source" };
 function createAdapterStamp(config) {
   let cachedCodeStamp = null;
@@ -1453,19 +1876,19 @@ function createAdapterStamp(config) {
 function readAdapterCodeStamp(moduleUrl) {
   try {
     const selfPath = (0, import_node_url.fileURLToPath)(moduleUrl);
-    const hash = computeDistHashFrom(import_node_path4.default.dirname(selfPath));
+    const hash = computeDistHashFrom(import_node_path5.default.dirname(selfPath), processCodeHasher);
     return hash.length > 0 ? { kind: "bundle", hash } : SOURCE_STAMP;
   } catch {
     return SOURCE_STAMP;
   }
 }
-function computeDistHashFrom(dir) {
-  const candidates = [import_node_path4.default.join(dir, "index.js"), import_node_path4.default.join(dir, "index.cjs")];
+function computeDistHashFrom(dir, hasher = createCodeHasher()) {
+  const candidates = [import_node_path5.default.join(dir, "index.js"), import_node_path5.default.join(dir, "index.cjs")];
   for (const candidate of candidates) {
-    if (!import_node_fs2.default.existsSync(candidate)) {
+    if (!import_node_fs3.default.existsSync(candidate)) {
       continue;
     }
-    return computeContentHash([candidate, ...analysisBundles()]);
+    return hasher.codeHash(candidate);
   }
   return "";
 }
@@ -1473,10 +1896,10 @@ function computeContentHash(paths) {
   if (paths.length === 0) {
     return "";
   }
-  const hash = (0, import_node_crypto.createHash)("sha256");
+  const hash = (0, import_node_crypto2.createHash)("sha256");
   for (const file of paths) {
     try {
-      hash.update(import_node_fs2.default.readFileSync(file));
+      hash.update(import_node_fs3.default.readFileSync(file));
     } catch {
       return "";
     }
@@ -1487,12 +1910,12 @@ function projectFileStamp(paths) {
   if (paths.length === 0) {
     return "none";
   }
-  const hash = (0, import_node_crypto.createHash)("sha256");
+  const hash = (0, import_node_crypto2.createHash)("sha256");
   for (const file of [...paths].sort()) {
     hash.update(file);
     hash.update("\0");
     try {
-      hash.update(import_node_fs2.default.readFileSync(file));
+      hash.update(import_node_fs3.default.readFileSync(file));
     } catch {
       hash.update("absent");
     }
@@ -1505,8 +1928,9 @@ function extractionConfigStamp(config) {
     ["includeReachable", optionalText(config.includeReachable)],
     ["workspaceRoot", config.workspaceRoot],
     ["projectRoot", config.projectRoot],
-    ["importRoots", config.importRoots?.join(import_node_path4.default.delimiter)],
-    ["modules", modulesStamp(config.modules)]
+    ["importRoots", config.importRoots?.join(import_node_path5.default.delimiter)],
+    ["modules", modulesStamp(config.modules)],
+    ["walkedDirectory", config.walkedDirectory]
   ];
   return parts.flatMap(
     ([name, value]) => value === void 0 ? [] : [`${name}=${value}`]
@@ -1519,25 +1943,283 @@ function runDigest(packsDigest, packs, files) {
   const inputs = packs.flatMap((pack) => pack.discoveryInputs?.(files) ?? []);
   return `${packsDigest}|reads:${projectFileStamp(inputs)}`;
 }
-function analysisBundles() {
-  const require2 = (0, import_node_module.createRequire)(import_meta.url);
-  const found = [];
-  for (const name of ANALYSIS_PACKAGES) {
-    try {
-      found.push(require2.resolve(name));
-    } catch {
+
+// src/cache.ts
+var import_node_crypto5 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var import_files3 = require("@suss/behavioral-ir/files");
+
+// src/cacheIndex.ts
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_files = require("@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),
+        import_behavioral_ir6.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 = (0, import_files.readJsonFile)(file);
+    return Array.isArray(index.files) ? index : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoreIndex(file, index) {
+  (0, import_files.writeDocumentFile)(file, index);
+}
+function keyOf3(binding) {
+  try {
+    return (0, import_behavioral_ir6.displayLabel)(binding);
+  } catch {
+    return null;
+  }
 }
 
-// src/cache.ts
+// src/cacheShards.ts
 var import_node_crypto3 = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_files2 = require("@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(import_node_path6.default.join(entryDir, SHARDS_DIR), interned(content));
+}
+function readShard(entryDir, id, file) {
+  const stored = readStored(import_node_path6.default.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(import_node_path6.default.join(entryDir, RECORDS_DIR), { meta });
+}
+function readRecord(entryDir, id) {
+  const stored = readStored(import_node_path6.default.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 = import_node_path6.default.join(entryDir, kind);
+    for (const prefix of namesIn(root)) {
+      const dir = import_node_path6.default.join(root, prefix);
+      for (const name of namesIn(dir)) {
+        if (STORED_ID.test(name) && !keep.has(name.slice(0, -".json".length))) {
+          import_node_fs4.default.rmSync(import_node_path6.default.join(dir, name), { force: true });
+        }
+      }
+    }
+  }
+}
+function namesIn(dir) {
+  try {
+    return import_node_fs4.default.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function writeOnce(root, value) {
+  const pieces = [...(0, import_files2.documentPieces)(value)];
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  for (const piece of pieces) {
+    hash.update(piece);
+  }
+  const id = hash.digest("hex").slice(0, 32);
+  const file = storedPath(root, id);
+  if (!import_node_fs4.default.existsSync(file)) {
+    (0, import_files2.writeFileAtomically)(file, pieces);
+  }
+  return id;
+}
+function readStored(root, id) {
+  try {
+    return (0, import_files2.readJsonFile)(storedPath(root, id));
+  } catch {
+    return void 0;
+  }
+}
+function storedPath(root, id) {
+  return import_node_path6.default.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
-var import_node_crypto2 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var import_promises = __toESM(require("fs/promises"), 1);
 var RECENT_CHANGE_MS = 2e3;
 function stampMayMissAWrite(stat, statAt) {
@@ -1627,7 +2309,7 @@ function reusableHash(prior, stamp) {
 async function hashFile(filePath) {
   try {
     const content = await import_promises.default.readFile(filePath);
-    return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+    return (0, import_node_crypto4.createHash)("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return null;
   }
@@ -1642,11 +2324,30 @@ function fileStampEquals(a, b) {
   return a.path === b.path && a.mtimeMs === b.mtimeMs && a.size === b.size;
 }
 
+// src/ignoredDirectory.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+function makeIgnoredDirectory(dir) {
+  import_node_fs5.default.mkdirSync(dir, { recursive: true });
+  const ignore = import_node_path7.default.join(dir, ".gitignore");
+  if (!import_node_fs5.default.existsSync(ignore)) {
+    import_node_fs5.default.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 {
@@ -1666,7 +2367,7 @@ function createCacheLayer(cacheDir) {
   const lookupWith = async (input, run) => {
     const entryDir = entryDirFor(cacheDir, input);
     const manifest = await manifests.readAtRunStart(
-      import_node_path5.default.join(entryDir, "manifest.json")
+      import_node_path8.default.join(entryDir, MANIFEST)
     );
     if (manifest === null) {
       return missDiag(await describeAbsentEntry(cacheDir));
@@ -1681,11 +2382,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" }
     };
   };
@@ -1705,10 +2410,8 @@ function createCacheLayer(cacheDir) {
     },
     async plan(input) {
       const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await manifests.readAgain(
-        import_node_path5.default.join(entryDir, "manifest.json")
-      );
-      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0 || manifest.owners === void 0) {
+      const manifest = await manifests.readAgain(import_node_path8.default.join(entryDir, MANIFEST));
+      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0) {
         return null;
       }
       const run = await runFor(input);
@@ -1719,14 +2422,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(
-        import_node_path5.default.join(entryDir, "manifest.json")
-      );
+      const previous = await manifests.readAgain(import_node_path8.default.join(entryDir, MANIFEST));
       manifests.forget();
       const known = runs.get(input);
       const run = known ?? await runFor(input);
@@ -1742,58 +2448,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 import_promises2.default.mkdir(entryDir, { recursive: true });
-      await import_promises2.default.writeFile(
-        import_node_path5.default.join(entryDir, "manifest.json"),
-        JSON.stringify(manifest)
+      (0, import_files3.writeDocumentFile)(import_node_path8.default.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 = import_node_path8.default.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 ?? [];
@@ -1803,23 +2570,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) {
@@ -1827,14 +2595,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
       }
     ];
   });
@@ -1852,7 +2620,7 @@ async function buildPlan(manifest, run) {
       }
     }
   }
-  const owners = manifest.owners ?? [];
+  const ownerPaths = ownersInRunOrder(manifest);
   return {
     changed,
     removed,
@@ -1864,36 +2632,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();
@@ -1909,10 +2722,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) }
   }));
@@ -1929,11 +2742,13 @@ 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) {
@@ -1950,8 +2765,8 @@ function entryDirFor(cacheDir, input) {
     input.adapterPacksDigest,
     input.configPath ?? ""
   ].join(" ");
-  const name = (0, import_node_crypto3.createHash)("sha256").update(key).digest("hex").slice(0, 16);
-  return import_node_path5.default.join(cacheDir, `${ENTRY_PREFIX}${name}`);
+  const name = (0, import_node_crypto5.createHash)("sha256").update(key).digest("hex").slice(0, 16);
+  return import_node_path8.default.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
 function isEntryDir(name) {
   return ENTRY_DIR_NAME.test(name);
@@ -1965,11 +2780,11 @@ async function markUsed(entryDir) {
 }
 async function evictOldEntries(cacheDir, keepDir) {
   try {
-    await import_promises2.default.rm(import_node_path5.default.join(cacheDir, "manifest.json"), { force: true });
+    await import_promises2.default.rm(import_node_path8.default.join(cacheDir, "manifest.json"), { force: true });
     const entries = await import_promises2.default.readdir(cacheDir, { withFileTypes: true });
     const dirs = await Promise.all(
       entries.filter((e) => e.isDirectory() && isEntryDir(e.name)).map(async (e) => {
-        const dir = import_node_path5.default.join(cacheDir, e.name);
+        const dir = import_node_path8.default.join(cacheDir, e.name);
         const stat = await import_promises2.default.stat(dir);
         return { dir, mtimeMs: stat.mtimeMs };
       })
@@ -1991,7 +2806,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;
   }
@@ -2014,17 +2829,54 @@ async function manifestStamp(manifestPath) {
     return null;
   }
 }
-async function readManifest(manifestPath) {
+async function readManifest2(manifestPath) {
   try {
-    const raw = await import_promises2.default.readFile(manifestPath, "utf-8");
-    return JSON.parse(raw);
+    const manifest = (0, import_files3.readJsonFile)(manifestPath);
+    return Array.isArray(manifest.shards) ? manifest : null;
   } catch {
     return null;
   }
 }
 
+// src/cacheLocation.ts
+var import_node_crypto6 = require("crypto");
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var CACHE_DIR_ENV = "SUSS_CACHE_DIR";
+function chosenCacheRoot() {
+  const chosen = process.env[CACHE_DIR_ENV];
+  if (chosen === void 0 || chosen === "") {
+    return null;
+  }
+  return import_node_path9.default.resolve(chosen);
+}
+function realPathOrSelf(dir) {
+  try {
+    return import_node_fs6.default.realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+function projectKey(projectDir) {
+  return (0, import_node_crypto6.createHash)("sha256").update(realPathOrSelf(import_node_path9.default.resolve(projectDir))).digest("hex").slice(0, 16);
+}
+function extractionCacheDirFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return import_node_path9.default.join(projectDir, ".suss", "cache");
+  }
+  return import_node_path9.default.join(root, "cache", projectKey(projectDir));
+}
+function liveRecordFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return import_node_path9.default.join(projectDir, ".suss", "live", "server.json");
+  }
+  return import_node_path9.default.join(root, "live", `${projectKey(projectDir)}.json`);
+}
+
 // src/extractionReport.ts
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var emptyTally = () => ({
   candidateFiles: 0,
   unitsDiscovered: 0,
@@ -2074,7 +2926,7 @@ function summaryCountsByPack(summaries) {
     }
     const entry = counts.get(recognition) ?? emptyCounts();
     entry.bound += 1;
-    if (import_behavioral_ir5.BOUNDARY_ROLE[summary.kind] === "provider") {
+    if (import_behavioral_ir7.BOUNDARY_ROLE[summary.kind] === "provider") {
       entry.providers += 1;
     }
     if (summary.transitions.length > 0) {
@@ -2299,6 +3151,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 [
@@ -2451,7 +3314,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 = (0, import_node_crypto4.createHash)("sha1").update(conditionSig).digest("hex").slice(0, 7);
+  const conditionHash = (0, import_node_crypto7.createHash)("sha1").update(conditionSig).digest("hex").slice(0, 7);
   return `${functionName}:${terminal.kind}:${statusKey}:${conditionHash}`;
 }
 function collapseReading(table, reading) {
@@ -2510,6 +3373,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)
   ];
@@ -2519,17 +3383,17 @@ function effectsOfBranch(branch) {
     ...branch.effects.map(effectToIR),
     ...branch.extraEffects ?? []
   ];
-  return (0, import_behavioral_ir6.foldRepeatedEffects)(effects.map(withNormalizedCallee));
+  return (0, import_behavioral_ir8.foldRepeatedEffects)(effects.map(withNormalizedCallee));
 }
 function provenanceOf(raw, effects) {
   if (raw.length === 0) {
     return [];
   }
-  const positionOf = new Map(effects.map((one, at) => [(0, import_behavioral_ir6.effectKey)(one), at]));
+  const positionOf = new Map(effects.map((one, at) => [(0, import_behavioral_ir8.effectKey)(one), at]));
   const bySlot = /* @__PURE__ */ new Map();
   const said = /* @__PURE__ */ new Map();
   for (const one of raw) {
-    const effect = positionOf.get((0, import_behavioral_ir6.effectKey)(withNormalizedCallee(one.effect)));
+    const effect = positionOf.get((0, import_behavioral_ir8.effectKey)(withNormalizedCallee(one.effect)));
     if (effect === void 0) {
       continue;
     }
@@ -2561,7 +3425,7 @@ function withNormalizedCallee(effect) {
   if (effect.callee === void 0) {
     return effect;
   }
-  return { ...effect, callee: (0, import_behavioral_ir6.normalizeCalleeText)(effect.callee) };
+  return { ...effect, callee: (0, import_behavioral_ir8.normalizeCalleeText)(effect.callee) };
 }
 function assembleSummary(raw, options = DEFAULT_OPTIONS) {
   const transitions = raw.branches.map((rawBranch) => {
@@ -2626,28 +3490,28 @@ function buildMetadata(raw) {
   let metadata = {};
   const http = buildHttpMetadataValue(raw);
   if (http !== null) {
-    metadata = (0, import_behavioral_ir6.withHttpMetadata)(metadata, http);
+    metadata = (0, import_behavioral_ir8.withHttpMetadata)(metadata, http);
   }
   const graphql = buildGraphqlMetadataValue(raw);
   if (graphql !== null) {
-    metadata = (0, import_behavioral_ir6.withGraphqlMetadata)(metadata, graphql);
+    metadata = (0, import_behavioral_ir8.withGraphqlMetadata)(metadata, graphql);
   }
   if (raw.sourceDocumentLabel !== void 0) {
-    metadata = (0, import_behavioral_ir6.withSourceDocumentMetadata)(metadata, {
+    metadata = (0, import_behavioral_ir8.withSourceDocumentMetadata)(metadata, {
       label: raw.sourceDocumentLabel
     });
   }
   if (raw.mount !== void 0) {
-    metadata = (0, import_behavioral_ir6.withMountMetadata)(metadata, raw.mount);
+    metadata = (0, import_behavioral_ir8.withMountMetadata)(metadata, raw.mount);
   }
   if (raw.wrappers !== void 0 && raw.wrappers.length > 0) {
-    metadata = (0, import_behavioral_ir6.withWrapperMetadata)(metadata, { applied: raw.wrappers });
+    metadata = (0, import_behavioral_ir8.withWrapperMetadata)(metadata, { applied: raw.wrappers });
   }
   if (raw.requestSpelling !== void 0) {
-    metadata = (0, import_behavioral_ir6.withRequestSpellingMetadata)(metadata, raw.requestSpelling);
+    metadata = (0, import_behavioral_ir8.withRequestSpellingMetadata)(metadata, raw.requestSpelling);
   }
   if (raw.test !== void 0) {
-    metadata = (0, import_behavioral_ir6.withTestMetadata)(metadata, raw.test);
+    metadata = (0, import_behavioral_ir8.withTestMetadata)(metadata, raw.test);
   }
   return Object.keys(metadata).length > 0 ? metadata : null;
 }
@@ -2672,6 +3536,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) {
@@ -2700,7 +3570,7 @@ function answersWithHttpResponses(raw) {
   if (raw.boundaryBinding === null || raw.boundaryBinding === void 0) {
     return true;
   }
-  return (0, import_behavioral_ir6.exchangesHttpResponses)(raw.boundaryBinding);
+  return (0, import_behavioral_ir8.exchangesHttpResponses)(raw.boundaryBinding);
 }
 function detectGaps(raw, transitions, options) {
   if (options.gapHandling === "silent") {
@@ -2739,13 +3609,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") {
@@ -2817,10 +3690,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) => ({
@@ -2890,11 +3769,13 @@ function paramToInput(param) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CACHE_DIR_ENV,
   EnclosingNodes,
   IdMap,
   IdSet,
   KeptParses,
   MAX_ENTRIES,
+  MAX_HELPER_PATHS,
   MAX_PATHS,
   MODULE_SURFACE_RECOGNITION,
   PathBudgetExceeded,
@@ -2906,6 +3787,7 @@ function paramToInput(param) {
   assembleSummary,
   assessConfidence,
   buildUngatedExtractionReport,
+  chosenCacheRoot,
   commonDirectoryOf,
   composeWrappers,
   computeContentHash,
@@ -2913,6 +3795,7 @@ function paramToInput(param) {
   configuredCallOption,
   createAdapterStamp,
   createCacheLayer,
+  createCodeHasher,
   createPackTallies,
   createTimer,
   detectGaps,
@@ -2921,24 +3804,33 @@ function paramToInput(param) {
   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,
@@ -2947,6 +3839,7 @@ function paramToInput(param) {
   settleModules,
   sharedGatingConditions,
   sourceRefsOf,
+  splitAtHandOffs,
   stampMayMissAWrite,
   stampModuleImports,
   stampModules,
@@ -2954,6 +3847,7 @@ function paramToInput(param) {
   summaryCountsByPack,
   tallyUnit,
   terminalToOutput,
+  throughHelper,
   unreadableReading,
   unwrapJsonStringify,
   valueToReadFurtherFrom,