@suss/extractor 0.34.1 → 0.35.1

package/dist/index.cjs

@@ -30,6 +30,7 @@ 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,
@@ -47,6 +48,7 @@ __export(index_exports, {
   assembleSummary: () => assembleSummary,
   assessConfidence: () => assessConfidence,
   buildUngatedExtractionReport: () => buildUngatedExtractionReport,
+  chosenCacheRoot: () => chosenCacheRoot,
   commonDirectoryOf: () => commonDirectoryOf,
   composeWrappers: () => composeWrappers,
   computeContentHash: () => computeContentHash,
@@ -54,6 +56,7 @@ __export(index_exports, {
   configuredCallOption: () => configuredCallOption,
   createAdapterStamp: () => createAdapterStamp,
   createCacheLayer: () => createCacheLayer,
+  createCodeHasher: () => createCodeHasher,
   createPackTallies: () => createPackTallies,
   createTimer: () => createTimer,
   detectGaps: () => detectGaps,
@@ -62,6 +65,7 @@ __export(index_exports, {
   enumerateOrDegrade: () => enumerateOrDegrade,
   enumerateStructuredPaths: () => enumerateStructuredPaths,
   evaluatePackHealth: () => evaluatePackHealth,
+  extractionCacheDirFor: () => extractionCacheDirFor,
   extractionConfigStamp: () => extractionConfigStamp,
   firstWrittenReading: () => firstWrittenReading,
   formatPackHealth: () => formatPackHealth,
@@ -69,6 +73,7 @@ __export(index_exports, {
   helperPathsOnVariables: () => helperPathsOnVariables,
   httpRouteDiscovery: () => httpRouteDiscovery,
   isListedTestFile: () => isListedTestFile,
+  liveRecordFor: () => liveRecordFor,
   makeIgnoredDirectory: () => makeIgnoredDirectory,
   makeTransitionId: () => makeTransitionId,
   mapReading: () => mapReading,
@@ -78,8 +83,11 @@ __export(index_exports, {
   moduleInitStructure: () => moduleInitStructure,
   moduleOfFile: () => moduleOfFile,
   noopTimer: () => noopTimer,
+  ownersWhereWritten: () => ownersWhereWritten,
+  packConfigCheck: () => packConfigCheck,
   packGradients: () => packGradients,
   paramToInput: () => paramToInput,
+  processCodeHasher: () => processCodeHasher,
   projectFileStamp: () => projectFileStamp,
   rawConditionToPredicate: () => rawConditionToPredicate,
   recordPackFailure: () => recordPackFailure,
@@ -109,8 +117,8 @@ __export(index_exports, {
   writtenReading: () => writtenReading
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_crypto4 = require("crypto");
-var import_behavioral_ir7 = 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");
@@ -661,7 +669,7 @@ function splitAtHandOffs(branch, sites, from = 0) {
       continue;
     }
     return throughHelper(branch, site.at, site.helper).flatMap(
-      (path7) => path7.terminal === branch.terminal ? splitAtHandOffs(path7, sites, index + 1) : [path7]
+      (path10) => path10.terminal === branch.terminal ? splitAtHandOffs(path10, sites, index + 1) : [path10]
     );
   }
   return [branch];
@@ -709,12 +717,12 @@ function rootName(ref) {
 }
 
 // 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()
@@ -1009,8 +1017,8 @@ var catchEntryCond = () => fixedCond(
   "positive",
   "catchBlock"
 );
-function classify(path7, home, isAncestorOrSelf) {
-  return path7.map((cond) => {
+function classify(path10, home, isAncestorOrSelf) {
+  return path10.map((cond) => {
     if (cond.branchStmt === null) {
       return cond.info;
     }
@@ -1082,9 +1090,9 @@ function limitOpenPaths(paths) {
     );
   }
 }
-function recordTerminal(ctx, terminal, home, path7) {
+function recordTerminal(ctx, terminal, home, path10) {
   chargeBudget(ctx.state);
-  const info = classify(path7, 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);
@@ -1095,15 +1103,15 @@ function containsTerminal(ctx, stmt) {
   }
   return childrenOf(stmt).some((child) => containsTerminal(ctx, child));
 }
-function stepIf(stmt, path7, ctx) {
+function stepIf(stmt, path10, ctx) {
   const thenExit = exitKindOfList(stmt.thenBody);
   const elseExit = stmt.elseBody === null ? null : exitKindOfList(stmt.elseBody);
   const thenPath = [
-    ...path7,
+    ...path10,
     branchCond(stmt, stmt.condition, "positive", elseExit)
   ];
   const elsePath = [
-    ...path7,
+    ...path10,
     branchCond(
       stmt,
       stmt.condition,
@@ -1120,7 +1128,7 @@ function stepIf(stmt, path7, ctx) {
   }
   return out;
 }
-function stepSwitch(stmt, path7, ctx) {
+function stepSwitch(stmt, path10, ctx) {
   const out = [];
   const negations = [];
   let defaultRanBody = false;
@@ -1130,7 +1138,7 @@ function stepSwitch(stmt, path7, ctx) {
     if (hasStrayBreak(group.body)) {
       throw new UnmodeledFlow("non-trailing break in switch clause");
     }
-    const groupPath = group.condition === null ? [...path7, ...negations] : [...path7, 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) {
@@ -1147,24 +1155,24 @@ function stepSwitch(stmt, path7, ctx) {
     }
   }
   if (!defaultRanBody) {
-    out.push([...path7, ...negations]);
+    out.push([...path10, ...negations]);
   }
   return out;
 }
-function stepLoop(stmt, path7, ctx) {
+function stepLoop(stmt, path10, ctx) {
   const bodyExit = exitKindOfList(stmt.body);
   if (containsTerminal(ctx, stmt)) {
     enumerate(ctx, stmt.body, [
-      ...path7,
+      ...path10,
       loopIterationCond(stmt.condition.sourceText)
     ]);
   }
   if (bodyExit !== null) {
-    return [[...path7, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
+    return [[...path10, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
   }
-  return [path7];
+  return [path10];
 }
-function stepTry(stmt, path7, ctx) {
+function stepTry(stmt, path10, ctx) {
   if (stmt.finallyBody !== null) {
     const finallyHasTerminal = stmt.finallyBody.some(
       (s) => containsTerminal(ctx, s)
@@ -1174,22 +1182,22 @@ function stepTry(stmt, path7, ctx) {
     }
   }
   const out = [];
-  out.push(...enumerate(ctx, stmt.tryBody, path7));
+  out.push(...enumerate(ctx, stmt.tryBody, path10));
   if (stmt.catchBody !== null) {
-    const catchPath = [...path7, catchEntryCond()];
+    const catchPath = [...path10, catchEntryCond()];
     out.push(...enumerate(ctx, stmt.catchBody, catchPath));
   }
   return out;
 }
-function stepExit(stmt, path7, 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(path7);
+    collector.push(path10);
   }
   return [];
 }
-function stepOpaque(_stmt, path7, _ctx) {
-  return [path7];
+function stepOpaque(_stmt, path10, _ctx) {
+  return [path10];
 }
 var stepHandlers = {
   if: stepIf,
@@ -1199,20 +1207,20 @@ var stepHandlers = {
   exit: stepExit,
   opaque: stepOpaque
 };
-function stepCallback(ctx, body, path7) {
+function stepCallback(ctx, body, path10) {
   const exits = [];
   ctx.state.callbackExits.push(exits);
   let fellThrough;
   try {
-    fellThrough = enumerate(ctx, body, path7);
+    fellThrough = enumerate(ctx, body, path10);
   } finally {
     ctx.state.callbackExits.pop();
   }
   const out = [...fellThrough, ...exits];
-  return out.length === 0 ? [path7] : out;
+  return out.length === 0 ? [path10] : out;
 }
-function stepStatement(ctx, stmt, path7) {
-  let paths = [path7];
+function stepStatement(ctx, stmt, path10) {
+  let paths = [path10];
   for (const body of stmt.callbacks ?? []) {
     paths = paths.flatMap((each) => stepCallback(ctx, body, each));
     limitOpenPaths(paths);
@@ -1299,8 +1307,8 @@ function enumerate(ctx, stmts, prefix) {
   let frontiers = [[...prefix]];
   for (const stmt of stmts) {
     const nextFrontiers = [];
-    for (const path7 of mergeRejoined(frontiers, ctx.keepsArms)) {
-      nextFrontiers.push(...stepStatement(ctx, stmt, path7));
+    for (const path10 of mergeRejoined(frontiers, ctx.keepsArms)) {
+      nextFrontiers.push(...stepStatement(ctx, stmt, path10));
     }
     frontiers = nextFrontiers;
     limitOpenPaths(frontiers);
@@ -1349,9 +1357,9 @@ function enumerateStructuredPaths(input) {
     isAncestorOrSelf
   };
   const continuations = withRejoined(enumerate(ctx, input.statements, []));
-  for (const path7 of continuations) {
+  for (const path10 of continuations) {
     chargeBudget(state);
-    state.fallthrough.push(classify(path7, null, isAncestorOrSelf));
+    state.fallthrough.push(classify(path10, null, isAncestorOrSelf));
   }
   return { byTerminal: state.byTerminal, fallthrough: state.fallthrough };
 }
@@ -1394,8 +1402,8 @@ function sharedGatingConditions(paths, readPredicate) {
     return [];
   }
   const shared = new Set(first.map(keyOf2));
-  for (const path7 of rest) {
-    const here = new Set(path7.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);
@@ -1661,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;
@@ -1707,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 "";
 }
@@ -1727,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 "";
     }
@@ -1741,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");
     }
@@ -1759,7 +1928,7 @@ function extractionConfigStamp(config) {
     ["includeReachable", optionalText(config.includeReachable)],
     ["workspaceRoot", config.workspaceRoot],
     ["projectRoot", config.projectRoot],
-    ["importRoots", config.importRoots?.join(import_node_path4.default.delimiter)],
+    ["importRoots", config.importRoots?.join(import_node_path5.default.delimiter)],
     ["modules", modulesStamp(config.modules)],
     ["walkedDirectory", config.walkedDirectory]
   ];
@@ -1774,26 +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_fs4 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
-var import_files = require("@suss/behavioral-ir/files");
+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) {
@@ -1883,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;
   }
@@ -1899,21 +2325,29 @@ function fileStampEquals(a, b) {
 }
 
 // src/ignoredDirectory.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 function makeIgnoredDirectory(dir) {
-  import_node_fs3.default.mkdirSync(dir, { recursive: true });
-  const ignore = import_node_path5.default.join(dir, ".gitignore");
-  if (!import_node_fs3.default.existsSync(ignore)) {
-    import_node_fs3.default.writeFileSync(ignore, "*\n");
+  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 {
@@ -1933,7 +2367,7 @@ function createCacheLayer(cacheDir) {
   const lookupWith = async (input, run) => {
     const entryDir = entryDirFor(cacheDir, input);
     const manifest = await manifests.readAtRunStart(
-      import_node_path6.default.join(entryDir, "manifest.json")
+      import_node_path8.default.join(entryDir, MANIFEST)
     );
     if (manifest === null) {
       return missDiag(await describeAbsentEntry(cacheDir));
@@ -1948,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" }
     };
   };
@@ -1972,10 +2410,8 @@ function createCacheLayer(cacheDir) {
     },
     async plan(input) {
       const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await manifests.readAgain(
-        import_node_path6.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);
@@ -1986,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_path6.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);
@@ -2009,55 +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
       };
-      makeIgnoredDirectory(cacheDir);
-      (0, import_files.writeDocumentFile)(import_node_path6.default.join(entryDir, "manifest.json"), 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 ?? [];
@@ -2067,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) {
@@ -2091,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
       }
     ];
   });
@@ -2116,7 +2620,7 @@ async function buildPlan(manifest, run) {
       }
     }
   }
-  const owners = manifest.owners ?? [];
+  const ownerPaths = ownersInRunOrder(manifest);
   return {
     changed,
     removed,
@@ -2128,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();
@@ -2173,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) }
   }));
@@ -2193,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) {
@@ -2214,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_path6.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);
@@ -2229,11 +2780,11 @@ async function markUsed(entryDir) {
 }
 async function evictOldEntries(cacheDir, keepDir) {
   try {
-    await import_promises2.default.rm(import_node_path6.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_path6.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 };
       })
@@ -2255,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;
   }
@@ -2278,16 +2829,54 @@ async function manifestStamp(manifestPath) {
     return null;
   }
 }
-async function readManifest(manifestPath) {
+async function readManifest2(manifestPath) {
   try {
-    return (0, import_files.readJsonFile)(manifestPath);
+    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_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var emptyTally = () => ({
   candidateFiles: 0,
   unitsDiscovered: 0,
@@ -2337,7 +2926,7 @@ function summaryCountsByPack(summaries) {
     }
     const entry = counts.get(recognition) ?? emptyCounts();
     entry.bound += 1;
-    if (import_behavioral_ir6.BOUNDARY_ROLE[summary.kind] === "provider") {
+    if (import_behavioral_ir7.BOUNDARY_ROLE[summary.kind] === "provider") {
       entry.providers += 1;
     }
     if (summary.transitions.length > 0) {
@@ -2562,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 [
@@ -2714,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) {
@@ -2783,17 +3383,17 @@ function effectsOfBranch(branch) {
     ...branch.effects.map(effectToIR),
     ...branch.extraEffects ?? []
   ];
-  return (0, import_behavioral_ir7.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_ir7.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_ir7.effectKey)(withNormalizedCallee(one.effect)));
+    const effect = positionOf.get((0, import_behavioral_ir8.effectKey)(withNormalizedCallee(one.effect)));
     if (effect === void 0) {
       continue;
     }
@@ -2825,7 +3425,7 @@ function withNormalizedCallee(effect) {
   if (effect.callee === void 0) {
     return effect;
   }
-  return { ...effect, callee: (0, import_behavioral_ir7.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) => {
@@ -2890,28 +3490,28 @@ function buildMetadata(raw) {
   let metadata = {};
   const http = buildHttpMetadataValue(raw);
   if (http !== null) {
-    metadata = (0, import_behavioral_ir7.withHttpMetadata)(metadata, http);
+    metadata = (0, import_behavioral_ir8.withHttpMetadata)(metadata, http);
   }
   const graphql = buildGraphqlMetadataValue(raw);
   if (graphql !== null) {
-    metadata = (0, import_behavioral_ir7.withGraphqlMetadata)(metadata, graphql);
+    metadata = (0, import_behavioral_ir8.withGraphqlMetadata)(metadata, graphql);
   }
   if (raw.sourceDocumentLabel !== void 0) {
-    metadata = (0, import_behavioral_ir7.withSourceDocumentMetadata)(metadata, {
+    metadata = (0, import_behavioral_ir8.withSourceDocumentMetadata)(metadata, {
       label: raw.sourceDocumentLabel
     });
   }
   if (raw.mount !== void 0) {
-    metadata = (0, import_behavioral_ir7.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_ir7.withWrapperMetadata)(metadata, { applied: raw.wrappers });
+    metadata = (0, import_behavioral_ir8.withWrapperMetadata)(metadata, { applied: raw.wrappers });
   }
   if (raw.requestSpelling !== void 0) {
-    metadata = (0, import_behavioral_ir7.withRequestSpellingMetadata)(metadata, raw.requestSpelling);
+    metadata = (0, import_behavioral_ir8.withRequestSpellingMetadata)(metadata, raw.requestSpelling);
   }
   if (raw.test !== void 0) {
-    metadata = (0, import_behavioral_ir7.withTestMetadata)(metadata, raw.test);
+    metadata = (0, import_behavioral_ir8.withTestMetadata)(metadata, raw.test);
   }
   return Object.keys(metadata).length > 0 ? metadata : null;
 }
@@ -2970,7 +3570,7 @@ function answersWithHttpResponses(raw) {
   if (raw.boundaryBinding === null || raw.boundaryBinding === void 0) {
     return true;
   }
-  return (0, import_behavioral_ir7.exchangesHttpResponses)(raw.boundaryBinding);
+  return (0, import_behavioral_ir8.exchangesHttpResponses)(raw.boundaryBinding);
 }
 function detectGaps(raw, transitions, options) {
   if (options.gapHandling === "silent") {
@@ -3169,6 +3769,7 @@ function paramToInput(param) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CACHE_DIR_ENV,
   EnclosingNodes,
   IdMap,
   IdSet,
@@ -3186,6 +3787,7 @@ function paramToInput(param) {
   assembleSummary,
   assessConfidence,
   buildUngatedExtractionReport,
+  chosenCacheRoot,
   commonDirectoryOf,
   composeWrappers,
   computeContentHash,
@@ -3193,6 +3795,7 @@ function paramToInput(param) {
   configuredCallOption,
   createAdapterStamp,
   createCacheLayer,
+  createCodeHasher,
   createPackTallies,
   createTimer,
   detectGaps,
@@ -3201,6 +3804,7 @@ function paramToInput(param) {
   enumerateOrDegrade,
   enumerateStructuredPaths,
   evaluatePackHealth,
+  extractionCacheDirFor,
   extractionConfigStamp,
   firstWrittenReading,
   formatPackHealth,
@@ -3208,6 +3812,7 @@ function paramToInput(param) {
   helperPathsOnVariables,
   httpRouteDiscovery,
   isListedTestFile,
+  liveRecordFor,
   makeIgnoredDirectory,
   makeTransitionId,
   mapReading,
@@ -3217,8 +3822,11 @@ function paramToInput(param) {
   moduleInitStructure,
   moduleOfFile,
   noopTimer,
+  ownersWhereWritten,
+  packConfigCheck,
   packGradients,
   paramToInput,
+  processCodeHasher,
   projectFileStamp,
   rawConditionToPredicate,
   recordPackFailure,