@suss/extractor 0.34.1 → 0.35.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
   effectKey,
   exchangesHttpResponses as exchangesHttpResponses2,
@@ -571,7 +571,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];
@@ -619,12 +619,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()
@@ -919,8 +919,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;
     }
@@ -992,9 +992,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);
@@ -1005,15 +1005,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,
@@ -1030,7 +1030,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;
@@ -1040,7 +1040,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) {
@@ -1057,24 +1057,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)
@@ -1084,22 +1084,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,
@@ -1109,20 +1109,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);
@@ -1209,8 +1209,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);
@@ -1259,9 +1259,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 };
 }
@@ -1304,8 +1304,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);
@@ -1571,17 +1571,179 @@ function quoted(text, key) {
 }
 
 // src/adapterStamp.ts
+import { createHash as createHash2 } from "crypto";
+import fs3 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+
+// src/codeHash.ts
 import { createHash } from "crypto";
 import fs2 from "fs";
 import { createRequire } from "module";
 import path4 from "path";
-import { fileURLToPath } from "url";
-var ANALYSIS_PACKAGES = [
-  "@suss/extractor",
-  "@suss/resolution",
-  "@suss/datalog",
-  "@suss/behavioral-ir"
-];
+var SUSS_SCOPE = "@suss/";
+var IMPORT_FORMS = /\b(?:from|import)\s*\(?\s*["']([^"'\s]+)["']|require\s*\(\s*["']([^"'\s]+)["']/g;
+var CONDITIONS = {
+  import: /* @__PURE__ */ new Set(["import", "node", "default"]),
+  require: /* @__PURE__ */ new Set(["require", "node", "default"])
+};
+function createCodeHasher() {
+  const read = /* @__PURE__ */ new Map();
+  function readOnce(file) {
+    const known = read.get(file);
+    if (known !== void 0) {
+      return known;
+    }
+    const found = readCodeFile(file);
+    read.set(file, found);
+    return found;
+  }
+  function codeFiles(entryFile) {
+    const entry = realFile(entryFile);
+    if (entry === null || readOnce(entry) === null) {
+      return [];
+    }
+    const found = [entry];
+    const seen = new Set(found);
+    for (let at = 0; at < found.length; at++) {
+      for (const next of readOnce(found[at])?.imports ?? []) {
+        if (seen.has(next)) {
+          continue;
+        }
+        seen.add(next);
+        if (readOnce(next) !== null) {
+          found.push(next);
+        }
+      }
+    }
+    return found;
+  }
+  function codeHash(entryFile) {
+    const files = codeFiles(entryFile);
+    if (files.length === 0) {
+      return "";
+    }
+    const hash = createHash("sha256");
+    for (const file of files) {
+      hash.update(read.get(file)?.digest ?? "");
+    }
+    return hash.digest("hex").slice(0, 16);
+  }
+  return { codeFiles, codeHash };
+}
+var processCodeHasher = createCodeHasher();
+function readCodeFile(file) {
+  let text;
+  try {
+    text = fs2.readFileSync(file);
+  } catch {
+    return null;
+  }
+  return {
+    digest: createHash("sha256").update(text).digest("hex"),
+    imports: importsOf(file, text.toString("utf8"))
+  };
+}
+function importsOf(file, text) {
+  const asked = /* @__PURE__ */ new Set();
+  const found = [];
+  for (const match of text.matchAll(IMPORT_FORMS)) {
+    const kind = match[1] === void 0 ? "require" : "import";
+    const specifier = match[1] ?? match[2] ?? "";
+    if (asked.has(`${kind} ${specifier}`)) {
+      continue;
+    }
+    asked.add(`${kind} ${specifier}`);
+    const target = resolveImport(specifier, file, kind);
+    if (target !== null) {
+      found.push(target);
+    }
+  }
+  return found;
+}
+function resolveImport(specifier, fromFile, kind) {
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    return realFile(path4.resolve(path4.dirname(fromFile), specifier));
+  }
+  if (specifier.startsWith(SUSS_SCOPE)) {
+    return resolvePackageImport(specifier, fromFile, kind);
+  }
+  return null;
+}
+function resolvePackageImport(specifier, fromFile, kind) {
+  const [scope = "", name = "", ...rest] = specifier.split("/");
+  const packageName = `${scope}/${name}`;
+  const subpath = rest.length === 0 ? "." : `./${rest.join("/")}`;
+  const lookIn = createRequire(fromFile).resolve.paths(packageName) ?? [];
+  for (const dir of lookIn) {
+    const packageDir = path4.join(dir, packageName);
+    const manifest = readManifest(packageDir);
+    if (manifest === null) {
+      continue;
+    }
+    const target = exportTarget(manifest, subpath, CONDITIONS[kind]);
+    return target === null ? null : realFile(path4.join(packageDir, target));
+  }
+  return null;
+}
+function readManifest(packageDir) {
+  try {
+    return JSON.parse(
+      fs2.readFileSync(path4.join(packageDir, "package.json"), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function exportTarget(manifest, subpath, conditions) {
+  if (manifest.exports === void 0) {
+    return subpath === "." ? manifest.main ?? "index.js" : subpath;
+  }
+  return conditionalTarget(subpathEntry(manifest.exports, subpath), conditions);
+}
+function subpathEntry(exportsField, subpath) {
+  const isSubpathMap = typeof exportsField === "object" && exportsField !== null && !Array.isArray(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."));
+  if (isSubpathMap) {
+    return exportsField[subpath];
+  }
+  return subpath === "." ? exportsField : void 0;
+}
+function conditionalTarget(value, conditions) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const each of value) {
+      const found = conditionalTarget(each, conditions);
+      if (found !== null) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (value === null || typeof value !== "object") {
+    return null;
+  }
+  for (const [condition, target] of Object.entries(value)) {
+    if (!conditions.has(condition)) {
+      continue;
+    }
+    const found = conditionalTarget(target, conditions);
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+}
+function realFile(file) {
+  try {
+    return fs2.realpathSync(file);
+  } catch {
+    return null;
+  }
+}
+
+// src/adapterStamp.ts
 var SOURCE_STAMP = { kind: "source" };
 function createAdapterStamp(config) {
   let cachedCodeStamp = null;
@@ -1616,19 +1778,19 @@ function createAdapterStamp(config) {
 function readAdapterCodeStamp(moduleUrl) {
   try {
     const selfPath = fileURLToPath(moduleUrl);
-    const hash = computeDistHashFrom(path4.dirname(selfPath));
+    const hash = computeDistHashFrom(path5.dirname(selfPath), processCodeHasher);
     return hash.length > 0 ? { kind: "bundle", hash } : SOURCE_STAMP;
   } catch {
     return SOURCE_STAMP;
   }
 }
-function computeDistHashFrom(dir) {
-  const candidates = [path4.join(dir, "index.js"), path4.join(dir, "index.cjs")];
+function computeDistHashFrom(dir, hasher = createCodeHasher()) {
+  const candidates = [path5.join(dir, "index.js"), path5.join(dir, "index.cjs")];
   for (const candidate of candidates) {
-    if (!fs2.existsSync(candidate)) {
+    if (!fs3.existsSync(candidate)) {
       continue;
     }
-    return computeContentHash([candidate, ...analysisBundles()]);
+    return hasher.codeHash(candidate);
   }
   return "";
 }
@@ -1636,10 +1798,10 @@ function computeContentHash(paths) {
   if (paths.length === 0) {
     return "";
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const file of paths) {
     try {
-      hash.update(fs2.readFileSync(file));
+      hash.update(fs3.readFileSync(file));
     } catch {
       return "";
     }
@@ -1650,12 +1812,12 @@ function projectFileStamp(paths) {
   if (paths.length === 0) {
     return "none";
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const file of [...paths].sort()) {
     hash.update(file);
     hash.update("\0");
     try {
-      hash.update(fs2.readFileSync(file));
+      hash.update(fs3.readFileSync(file));
     } catch {
       hash.update("absent");
     }
@@ -1668,7 +1830,7 @@ function extractionConfigStamp(config) {
     ["includeReachable", optionalText(config.includeReachable)],
     ["workspaceRoot", config.workspaceRoot],
     ["projectRoot", config.projectRoot],
-    ["importRoots", config.importRoots?.join(path4.delimiter)],
+    ["importRoots", config.importRoots?.join(path5.delimiter)],
     ["modules", modulesStamp(config.modules)],
     ["walkedDirectory", config.walkedDirectory]
   ];
@@ -1683,27 +1845,288 @@ function runDigest(packsDigest, packs, files) {
   const inputs = packs.flatMap((pack) => pack.discoveryInputs?.(files) ?? []);
   return `${packsDigest}|reads:${projectFileStamp(inputs)}`;
 }
-function analysisBundles() {
-  const require2 = createRequire(import.meta.url);
-  const found = [];
-  for (const name of ANALYSIS_PACKAGES) {
-    try {
-      found.push(require2.resolve(name));
-    } catch {
+
+// src/cache.ts
+import { createHash as createHash5 } from "crypto";
+import fs7 from "fs/promises";
+import path8 from "path";
+import { readJsonFile as readJsonFile3, writeDocumentFile as writeDocumentFile2 } from "@suss/behavioral-ir/files";
+
+// src/cacheIndex.ts
+import { BOUNDARY_ROLE, displayLabel } from "@suss/behavioral-ir";
+import { readJsonFile, writeDocumentFile } from "@suss/behavioral-ir/files";
+function entriesOf(units) {
+  const boundaries = [];
+  const callees = [];
+  units.forEach((summary, unit) => {
+    const seen = /* @__PURE__ */ new Set();
+    const add = (key, role) => {
+      if (key !== null && !seen.has(`${role} ${key}`)) {
+        seen.add(`${role} ${key}`);
+        boundaries.push([key, unit, role]);
+      }
+    };
+    const own = summary.identity?.boundaryBinding ?? null;
+    if (own !== null) {
+      add(
+        keyOf3(own),
+        BOUNDARY_ROLE[summary.kind] === "provider" ? "serves" : "calls"
+      );
+    }
+    const spellings = /* @__PURE__ */ new Set();
+    for (const transition of summary.transitions ?? []) {
+      for (const effect of transition.effects ?? []) {
+        if (effect.type === "interaction") {
+          add(keyOf3(effect.binding), "calls");
+        }
+        if (effect.type === "invocation") {
+          spellings.add(effect.callee);
+        }
+      }
+    }
+    for (const spelling of spellings) {
+      callees.push([spelling, unit]);
+    }
+  });
+  return { boundaries, callees };
+}
+function indexOf(shards) {
+  const boundaries = {};
+  const callees = {};
+  shards.forEach(({ entries }, file) => {
+    for (const [key, unit, role] of entries.boundaries) {
+      listAt(boundaries, key).push([file, unit, role]);
+    }
+    for (const [spelling, unit] of entries.callees) {
+      listAt(callees, spelling).push([file, unit]);
+    }
+  });
+  return {
+    files: shards.map(({ file, id }) => [file, id]),
+    boundaries,
+    callees
+  };
+}
+function listAt(record, key) {
+  const existing = Object.hasOwn(record, key) ? record[key] : void 0;
+  if (existing !== void 0) {
+    return existing;
+  }
+  const created = [];
+  record[key] = created;
+  return created;
+}
+function entriesByShard(index) {
+  const byShard = /* @__PURE__ */ new Map();
+  const at = index.files.map(([, id]) => {
+    const entries = { boundaries: [], callees: [] };
+    byShard.set(id, entries);
+    return entries;
+  });
+  for (const [key, units] of Object.entries(index.boundaries)) {
+    for (const [file, unit, role] of units) {
+      at[file]?.boundaries.push([key, unit, role]);
     }
   }
-  return found;
+  for (const [spelling, units] of Object.entries(index.callees)) {
+    for (const [file, unit] of units) {
+      at[file]?.callees.push([spelling, unit]);
+    }
+  }
+  return byShard;
+}
+function readStoreIndex(file) {
+  try {
+    const index = readJsonFile(file);
+    return Array.isArray(index.files) ? index : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoreIndex(file, index) {
+  writeDocumentFile(file, index);
+}
+function keyOf3(binding) {
+  try {
+    return displayLabel(binding);
+  } catch {
+    return null;
+  }
 }
 
-// src/cache.ts
+// src/cacheShards.ts
 import { createHash as createHash3 } from "crypto";
-import fs5 from "fs/promises";
+import fs4 from "fs";
 import path6 from "path";
-import { readJsonFile, writeDocumentFile } from "@suss/behavioral-ir/files";
+import {
+  documentPieces,
+  readJsonFile as readJsonFile2,
+  writeFileAtomically
+} from "@suss/behavioral-ir/files";
+var SHARDS_DIR = "shards";
+var RECORDS_DIR = "records";
+var STORED_ID = /^[0-9a-f]{32}\.json$/;
+function writeShard(entryDir, content) {
+  return writeOnce(path6.join(entryDir, SHARDS_DIR), interned(content));
+}
+function readShard(entryDir, id, file) {
+  const stored = readStored(path6.join(entryDir, SHARDS_DIR), id);
+  if (stored?.file !== file || !Array.isArray(stored.units)) {
+    return null;
+  }
+  const take = takerFor(stored.intern ?? []);
+  return {
+    file: stored.file,
+    units: stored.units.map((unit) => expanded(unit, take))
+  };
+}
+function writeRecord(entryDir, meta) {
+  return writeOnce(path6.join(entryDir, RECORDS_DIR), { meta });
+}
+function readRecord(entryDir, id) {
+  const stored = readStored(path6.join(entryDir, RECORDS_DIR), id);
+  return typeof stored === "object" && stored !== null ? stored : null;
+}
+function recordReader(entryDir) {
+  const opened = /* @__PURE__ */ new Map();
+  return (id) => {
+    if (!opened.has(id)) {
+      const record2 = readRecord(entryDir, id);
+      opened.set(id, record2);
+      return record2;
+    }
+    const record = opened.get(id) ?? null;
+    return record === null ? null : copyOfJson(record);
+  };
+}
+function removeStoredOutside(entryDir, keep) {
+  for (const kind of [SHARDS_DIR, RECORDS_DIR]) {
+    const root = path6.join(entryDir, kind);
+    for (const prefix of namesIn(root)) {
+      const dir = path6.join(root, prefix);
+      for (const name of namesIn(dir)) {
+        if (STORED_ID.test(name) && !keep.has(name.slice(0, -".json".length))) {
+          fs4.rmSync(path6.join(dir, name), { force: true });
+        }
+      }
+    }
+  }
+}
+function namesIn(dir) {
+  try {
+    return fs4.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function writeOnce(root, value) {
+  const pieces = [...documentPieces(value)];
+  const hash = createHash3("sha256");
+  for (const piece of pieces) {
+    hash.update(piece);
+  }
+  const id = hash.digest("hex").slice(0, 32);
+  const file = storedPath(root, id);
+  if (!fs4.existsSync(file)) {
+    writeFileAtomically(file, pieces);
+  }
+  return id;
+}
+function readStored(root, id) {
+  try {
+    return readJsonFile2(storedPath(root, id));
+  } catch {
+    return void 0;
+  }
+}
+function storedPath(root, id) {
+  return path6.join(root, id.slice(0, 2), `${id}.json`);
+}
+function interned(content) {
+  const intern = [];
+  const byText = /* @__PURE__ */ new Map();
+  const byObject = /* @__PURE__ */ new Map();
+  const positionOf = (value) => {
+    const known = byObject.get(value);
+    if (known !== void 0) {
+      return known;
+    }
+    const text = JSON.stringify(value) ?? "null";
+    let position = byText.get(text);
+    if (position === void 0) {
+      position = intern.length;
+      intern.push(value);
+      byText.set(text, position);
+    }
+    if (typeof value === "object" && value !== null) {
+      byObject.set(value, position);
+    }
+    return position;
+  };
+  const positions = (values) => Array.isArray(values) ? values.map(positionOf) : values;
+  const units = content.units.map((summary) => ({
+    ...summary,
+    transitions: summary.transitions.map((transition) => ({
+      ...transition,
+      conditions: positions(transition.conditions),
+      effects: positions(transition.effects)
+    })),
+    gaps: summary.gaps.map((gap) => ({
+      ...gap,
+      conditions: positions(gap.conditions)
+    }))
+  }));
+  return {
+    file: content.file,
+    intern,
+    units
+  };
+}
+function expanded(unit, take) {
+  const values = (positions) => Array.isArray(positions) ? positions.map((at) => take(at)) : positions;
+  const transitions = Array.isArray(unit.transitions) ? unit.transitions : [];
+  const gaps = Array.isArray(unit.gaps) ? unit.gaps : [];
+  return {
+    ...unit,
+    transitions: transitions.map((transition) => ({
+      ...transition,
+      conditions: values(transition.conditions),
+      effects: values(transition.effects)
+    })),
+    gaps: gaps.map((gap) => ({
+      ...gap,
+      conditions: values(gap.conditions)
+    }))
+  };
+}
+function takerFor(intern) {
+  const handedOut = /* @__PURE__ */ new Set();
+  return (position) => {
+    const value = intern[position];
+    if (!handedOut.has(position)) {
+      handedOut.add(position);
+      return value;
+    }
+    return copyOfJson(value);
+  };
+}
+function copyOfJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(copyOfJson);
+  }
+  if (typeof value === "object" && value !== null) {
+    const copy = {};
+    for (const key of Object.keys(value)) {
+      copy[key] = copyOfJson(value[key]);
+    }
+    return copy;
+  }
+  return value;
+}
 
 // src/cacheStamps.ts
-import { createHash as createHash2 } from "crypto";
-import fs3 from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import fs5 from "fs/promises";
 var RECENT_CHANGE_MS = 2e3;
 function stampMayMissAWrite(stat, statAt) {
   return Math.max(stat.mtimeMs, stat.ctimeMs) > statAt - RECENT_CHANGE_MS;
@@ -1724,7 +2147,7 @@ async function startRun(files, configPath) {
 }
 async function statAtStart(filePath) {
   try {
-    const stat = await fs3.stat(filePath);
+    const stat = await fs5.stat(filePath);
     return {
       stamp: { path: filePath, mtimeMs: stat.mtimeMs, size: stat.size },
       ctimeMs: stat.ctimeMs
@@ -1774,7 +2197,7 @@ async function recordedStamp(start, run, prior) {
     return start.stamp;
   }
   const filePath = start.stamp.path;
-  const now = await fs3.stat(filePath).catch(() => null);
+  const now = await fs5.stat(filePath).catch(() => null);
   if (now === null || now.mtimeMs !== start.stamp.mtimeMs || now.size !== start.stamp.size || now.ctimeMs !== start.ctimeMs) {
     return null;
   }
@@ -1791,8 +2214,8 @@ function reusableHash(prior, stamp) {
 }
 async function hashFile(filePath) {
   try {
-    const content = await fs3.readFile(filePath);
-    return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+    const content = await fs5.readFile(filePath);
+    return createHash4("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return null;
   }
@@ -1808,21 +2231,29 @@ function fileStampEquals(a, b) {
 }
 
 // src/ignoredDirectory.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function makeIgnoredDirectory(dir) {
-  fs4.mkdirSync(dir, { recursive: true });
-  const ignore = path5.join(dir, ".gitignore");
-  if (!fs4.existsSync(ignore)) {
-    fs4.writeFileSync(ignore, "*\n");
+  fs6.mkdirSync(dir, { recursive: true });
+  const ignore = path7.join(dir, ".gitignore");
+  if (!fs6.existsSync(ignore)) {
+    fs6.writeFileSync(ignore, "*\n");
   }
 }
 
 // src/cache.ts
-var SCHEMA_VERSION = "9";
+var SCHEMA_VERSION = "10";
+var MANIFEST = "manifest.json";
+var INDEX = "index.json";
 var MAX_ENTRIES = 2;
 var ENTRY_PREFIX = "key-";
 var ENTRY_DIR_NAME = new RegExp(`^${ENTRY_PREFIX}[0-9a-f]{16}$`);
+function ownersWhereWritten(summaries, walkedFileOf) {
+  return summaries.map((summary) => {
+    const walked = walkedFileOf(summary.location.file);
+    return walked === void 0 ? [] : [walked];
+  });
+}
 function createCacheLayer(cacheDir) {
   if (cacheDir === null) {
     return {
@@ -1842,7 +2273,7 @@ function createCacheLayer(cacheDir) {
   const lookupWith = async (input, run) => {
     const entryDir = entryDirFor(cacheDir, input);
     const manifest = await manifests.readAtRunStart(
-      path6.join(entryDir, "manifest.json")
+      path8.join(entryDir, MANIFEST)
     );
     if (manifest === null) {
       return missDiag(await describeAbsentEntry(cacheDir));
@@ -1857,11 +2288,15 @@ function createCacheLayer(cacheDir) {
     if (!await filesStillMatch(manifest.files, run)) {
       return missDiag("files-changed");
     }
+    const summaries = storedSummaries(entryDir, manifest);
+    if (summaries === null) {
+      return missDiag("no-manifest");
+    }
     await markUsed(entryDir);
     manifests.forget();
     return {
       kind: "hit",
-      summaries: manifest.summaries,
+      summaries,
       diagnostic: { kind: "hit" }
     };
   };
@@ -1881,10 +2316,8 @@ function createCacheLayer(cacheDir) {
     },
     async plan(input) {
       const entryDir = entryDirFor(cacheDir, input);
-      const manifest = await manifests.readAgain(
-        path6.join(entryDir, "manifest.json")
-      );
-      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0 || manifest.owners === void 0) {
+      const manifest = await manifests.readAgain(path8.join(entryDir, MANIFEST));
+      if (manifest === null || manifest.roots === void 0 || manifest.rootMeta === void 0) {
         return null;
       }
       const run = await runFor(input);
@@ -1895,14 +2328,17 @@ function createCacheLayer(cacheDir) {
       )) {
         return null;
       }
+      const summaries = storedSummaries(entryDir, manifest);
+      const records = storedRecords(entryDir, manifest);
+      if (summaries === null || records === null) {
+        return null;
+      }
       await markUsed(entryDir);
-      return buildPlan(manifest, run);
+      return buildPlan(manifest, records, summaries, run);
     },
     async write(input, summaries, attribution) {
       const entryDir = entryDirFor(cacheDir, input);
-      const previous = await manifests.readAgain(
-        path6.join(entryDir, "manifest.json")
-      );
+      const previous = await manifests.readAgain(path8.join(entryDir, MANIFEST));
       manifests.forget();
       const known = runs.get(input);
       const run = known ?? await runFor(input);
@@ -1918,55 +2354,119 @@ function createCacheLayer(cacheDir) {
         )
       );
       const files = recorded.filter((stamp) => stamp !== null);
+      const encoded = attribution === void 0 ? null : encodeAttribution(
+        attribution,
+        (meta) => writeRecord(entryDir, meta)
+      );
+      makeIgnoredDirectory(cacheDir);
+      const shards = writeShards(entryDir, summaries, encoded);
       const manifest = {
         schemaVersion: SCHEMA_VERSION,
         adapterPacksDigest: input.adapterPacksDigest,
         configStamp,
         files,
-        summaries,
-        ...attribution === void 0 ? {} : encodeAttribution(attribution)
+        summaryCount: summaries.length,
+        shards,
+        ...encoded === null ? {} : encoded.stored
       };
-      makeIgnoredDirectory(cacheDir);
-      writeDocumentFile(path6.join(entryDir, "manifest.json"), manifest);
+      writeDocumentFile2(path8.join(entryDir, MANIFEST), manifest);
+      removeStoredOutside(
+        entryDir,
+        /* @__PURE__ */ new Set([...storedIds(manifest), ...storedIds(previous)])
+      );
       await evictOldEntries(cacheDir, entryDir);
     }
   };
 }
-async function buildPlan(manifest, run) {
-  const stored = new Map(manifest.files.map((f) => [f.path, f]));
-  const current = new Map(run.files.map((f) => [f.stamp.path, f.stamp]));
-  const changed = /* @__PURE__ */ new Set();
-  const added = /* @__PURE__ */ new Set();
-  const removed = /* @__PURE__ */ new Set();
-  for (const p of stored.keys()) {
-    if (!current.has(p)) {
-      removed.add(p);
+function storedIds(manifest) {
+  return [
+    ...(manifest?.shards ?? []).map((shard) => shard.id),
+    ...(manifest?.rootMeta ?? []).flatMap(
+      (root) => root.record === void 0 ? [] : [root.record]
+    )
+  ];
+}
+function writeShards(entryDir, summaries, encoded) {
+  const byFile = /* @__PURE__ */ new Map();
+  summaries.forEach((summary, position) => {
+    const file = summary.location?.file ?? "";
+    const shard = byFile.get(file) ?? {
+      content: { file, units: [] },
+      order: [],
+      owners: []
+    };
+    byFile.set(file, shard);
+    shard.content.units.push(summary);
+    shard.order.push(position);
+    shard.owners.push(encoded?.owners[position] ?? []);
+  });
+  const indexFile = path8.join(entryDir, INDEX);
+  const before = readStoreIndex(indexFile);
+  const known = before === null ? /* @__PURE__ */ new Map() : entriesByShard(before);
+  const sorted = [...byFile].sort(([a], [b]) => a < b ? -1 : 1);
+  const written = sorted.map(([file, { content, order, owners }]) => {
+    const id = writeShard(entryDir, content);
+    return {
+      shard: {
+        file,
+        id,
+        order,
+        ...encoded === null ? {} : { owners }
+      },
+      entries: known.get(id) ?? entriesOf(content.units)
+    };
+  });
+  writeStoreIndex(
+    indexFile,
+    indexOf(
+      written.map(({ shard, entries }) => ({
+        file: shard.file,
+        id: shard.id,
+        entries
+      }))
+    )
+  );
+  return written.map(({ shard }) => shard);
+}
+function storedSummaries(entryDir, manifest) {
+  const summaries = new Array(
+    manifest.summaryCount
+  );
+  for (const shard of manifest.shards) {
+    const content = readShard(entryDir, shard.id, shard.file);
+    if (content === null || content.units.length !== shard.order.length) {
+      return null;
     }
+    shard.order.forEach((position, i) => {
+      summaries[position] = content.units[i];
+    });
   }
-  const toVerify = [];
-  for (const [p, stamp] of current) {
-    const before = stored.get(p);
-    if (before === void 0) {
-      changed.add(p);
-      added.add(p);
-    } else if (!fileStampEquals(before, stamp)) {
-      if (before.contentHash === void 0) {
-        changed.add(p);
-      } else {
-        toVerify.push(p);
-      }
-    } else if (before.verifyHash === true) {
-      toVerify.push(p);
+  for (let position = 0; position < summaries.length; position++) {
+    if (summaries[position] === void 0) {
+      return null;
     }
   }
-  await Promise.all(
-    toVerify.map(async (p) => {
-      const hash = await hashOf(run, p);
-      if (hash === null || hash !== stored.get(p)?.contentHash) {
-        changed.add(p);
-      }
-    })
-  );
+  return summaries;
+}
+function storedRecords(entryDir, manifest) {
+  const records = /* @__PURE__ */ new Map();
+  const roots = manifest.roots ?? [];
+  const readRecord2 = recordReader(entryDir);
+  for (const [i, root] of (manifest.rootMeta ?? []).entries()) {
+    const rootPath = roots[i];
+    if (rootPath === void 0 || root.record === void 0) {
+      continue;
+    }
+    const record = readRecord2(root.record);
+    if (record === null) {
+      return null;
+    }
+    records.set(rootPath, record.meta);
+  }
+  return records;
+}
+async function buildPlan(manifest, records, stored, run) {
+  const { changed, added, removed } = await changedSince(manifest, run);
   const roots = /* @__PURE__ */ new Map();
   const rootNames = manifest.roots ?? [];
   const depPaths = manifest.depPaths ?? [];
@@ -1976,23 +2476,24 @@ async function buildPlan(manifest, run) {
   });
   let rootsDeclined = 0;
   rootNames.forEach((rootPath, i) => {
-    const meta = manifest.rootMeta?.[i];
-    if (meta === void 0) {
+    const record = manifest.rootMeta?.[i];
+    if (record === void 0) {
       return;
     }
-    if (!meta.cacheable) {
+    if (!record.cacheable) {
       rootsDeclined += 1;
     }
     roots.set(rootPath, {
       path: rootPath,
-      cacheable: meta.cacheable,
-      deps: pathsOf(meta.deps),
-      claims: meta.claims,
-      meta: meta.meta,
-      packs: meta.packs,
-      ...meta.imports === void 0 ? {} : { imports: pathsOf(meta.imports) }
+      cacheable: record.cacheable,
+      deps: pathsOf(record.deps),
+      claims: record.claims,
+      meta: records.get(rootPath),
+      packs: record.packs,
+      ...record.imports === void 0 ? {} : { imports: pathsOf(record.imports) }
     });
   });
+  const current = new Set(run.files.map((f) => f.stamp.path));
   const unchanged = (filePath, deps) => current.has(filePath) && !changed.has(filePath) && !deps.some((d) => changed.has(d) || removed.has(d));
   const validRoots = /* @__PURE__ */ new Set();
   for (const [rootPath, record] of roots) {
@@ -2000,14 +2501,14 @@ async function buildPlan(manifest, run) {
       validRoots.add(rootPath);
     }
   }
-  const units = (manifest.units ?? []).flatMap((stored2) => {
-    const file = depPaths[stored2.file];
+  const units = (manifest.units ?? []).flatMap((unit) => {
+    const file = depPaths[unit.file];
     return file === void 0 ? [] : [
       {
-        key: stored2.key,
+        key: unit.key,
         file,
-        deps: pathsOf(stored2.deps),
-        data: stored2.data
+        deps: pathsOf(unit.deps),
+        data: unit.data
       }
     ];
   });
@@ -2025,7 +2526,7 @@ async function buildPlan(manifest, run) {
       }
     }
   }
-  const owners = manifest.owners ?? [];
+  const ownerPaths = ownersInRunOrder(manifest);
   return {
     changed,
     removed,
@@ -2037,36 +2538,81 @@ async function buildPlan(manifest, run) {
     reuse(valid) {
       const summaries = [];
       const reusedOwners = [];
-      manifest.summaries.forEach((summary, i) => {
-        const ownerPaths = (owners[i] ?? []).flatMap((o) => {
-          const p = rootNames[o];
-          return p === void 0 ? [] : [p];
-        });
-        if (ownerPaths.some((p) => valid.has(p))) {
+      stored.forEach((summary, i) => {
+        const owners = ownerPaths[i] ?? [];
+        if (owners.some((p) => valid.has(p))) {
           summaries.push(summary);
-          reusedOwners.push(ownerPaths.filter((p) => valid.has(p)));
+          reusedOwners.push(owners.filter((p) => valid.has(p)));
         }
       });
       return { summaries, owners: reusedOwners };
     },
     allSummaries() {
-      return manifest.summaries;
+      return stored;
     },
     attribution() {
       return {
         roots: [...roots.values()],
-        owners: owners.map(
-          (ownerIds) => ownerIds.flatMap((o) => {
-            const p = rootNames[o];
-            return p === void 0 ? [] : [p];
-          })
-        ),
+        owners: ownerPaths,
         units
       };
     }
   };
 }
-function encodeAttribution(attribution) {
+function ownersInRunOrder(manifest) {
+  const rootNames = manifest.roots ?? [];
+  const owners = Array.from(
+    { length: manifest.summaryCount },
+    () => []
+  );
+  for (const shard of manifest.shards ?? []) {
+    shard.order.forEach((position, i) => {
+      owners[position] = (shard.owners?.[i] ?? []).flatMap((o) => {
+        const p = rootNames[o];
+        return p === void 0 ? [] : [p];
+      });
+    });
+  }
+  return owners;
+}
+async function changedSince(manifest, run) {
+  const stored = new Map(manifest.files.map((f) => [f.path, f]));
+  const current = new Map(run.files.map((f) => [f.stamp.path, f.stamp]));
+  const changed = /* @__PURE__ */ new Set();
+  const added = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  for (const p of stored.keys()) {
+    if (!current.has(p)) {
+      removed.add(p);
+    }
+  }
+  const toVerify = [];
+  for (const [p, stamp] of current) {
+    const before = stored.get(p);
+    if (before === void 0) {
+      changed.add(p);
+      added.add(p);
+    } else if (!fileStampEquals(before, stamp)) {
+      if (before.contentHash === void 0) {
+        changed.add(p);
+      } else {
+        toVerify.push(p);
+      }
+    } else if (before.verifyHash === true) {
+      toVerify.push(p);
+    }
+  }
+  await Promise.all(
+    toVerify.map(async (p) => {
+      const hash = await hashOf(run, p);
+      if (hash === null || hash !== stored.get(p)?.contentHash) {
+        changed.add(p);
+      }
+    })
+  );
+  return { changed, added, removed };
+}
+function encodeAttribution(attribution, storeRecord) {
   const roots = attribution.roots.map((r) => r.path);
   const rootIndex = new Map(roots.map((p, i) => [p, i]));
   const depIndex = /* @__PURE__ */ new Map();
@@ -2082,10 +2628,10 @@ function encodeAttribution(attribution) {
     return id;
   };
   const rootMeta = attribution.roots.map((r) => ({
+    ...r.meta === void 0 ? {} : { record: storeRecord(r.meta) },
     cacheable: r.cacheable,
     deps: r.deps.map(depIdOf),
     claims: r.claims,
-    meta: r.meta,
     packs: r.packs,
     ...r.imports === void 0 ? {} : { imports: r.imports.map(depIdOf) }
   }));
@@ -2102,16 +2648,18 @@ function encodeAttribution(attribution) {
     data: unit.data
   }));
   return {
-    roots,
-    rootMeta,
-    depPaths,
-    owners,
-    ...units === void 0 ? {} : { units }
+    stored: {
+      roots,
+      rootMeta,
+      depPaths,
+      ...units === void 0 ? {} : { units }
+    },
+    owners
   };
 }
 async function describeAbsentEntry(cacheDir) {
   try {
-    const entries = await fs5.readdir(cacheDir, { withFileTypes: true });
+    const entries = await fs7.readdir(cacheDir, { withFileTypes: true });
     return entries.some((e) => e.isDirectory() && isEntryDir(e.name)) ? "key-changed" : "no-manifest";
   } catch {
     return "no-manifest";
@@ -2123,8 +2671,8 @@ function entryDirFor(cacheDir, input) {
     input.adapterPacksDigest,
     input.configPath ?? ""
   ].join(" ");
-  const name = createHash3("sha256").update(key).digest("hex").slice(0, 16);
-  return path6.join(cacheDir, `${ENTRY_PREFIX}${name}`);
+  const name = createHash5("sha256").update(key).digest("hex").slice(0, 16);
+  return path8.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
 function isEntryDir(name) {
   return ENTRY_DIR_NAME.test(name);
@@ -2132,24 +2680,24 @@ function isEntryDir(name) {
 async function markUsed(entryDir) {
   const now = /* @__PURE__ */ new Date();
   try {
-    await fs5.utimes(entryDir, now, now);
+    await fs7.utimes(entryDir, now, now);
   } catch {
   }
 }
 async function evictOldEntries(cacheDir, keepDir) {
   try {
-    await fs5.rm(path6.join(cacheDir, "manifest.json"), { force: true });
-    const entries = await fs5.readdir(cacheDir, { withFileTypes: true });
+    await fs7.rm(path8.join(cacheDir, "manifest.json"), { force: true });
+    const entries = await fs7.readdir(cacheDir, { withFileTypes: true });
     const dirs = await Promise.all(
       entries.filter((e) => e.isDirectory() && isEntryDir(e.name)).map(async (e) => {
-        const dir = path6.join(cacheDir, e.name);
-        const stat = await fs5.stat(dir);
+        const dir = path8.join(cacheDir, e.name);
+        const stat = await fs7.stat(dir);
         return { dir, mtimeMs: stat.mtimeMs };
       })
     );
     const doomed = dirs.filter((d) => d.dir !== keepDir).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(MAX_ENTRIES - 1);
     await Promise.all(
-      doomed.map((d) => fs5.rm(d.dir, { recursive: true, force: true }))
+      doomed.map((d) => fs7.rm(d.dir, { recursive: true, force: true }))
     );
   } catch {
   }
@@ -2164,7 +2712,7 @@ var ManifestReads = class {
   last = null;
   async readAtRunStart(manifestPath) {
     const stamp = await manifestStamp(manifestPath);
-    const manifest = await readManifest(manifestPath);
+    const manifest = await readManifest2(manifestPath);
     this.last = { path: manifestPath, stamp, manifest };
     return manifest;
   }
@@ -2181,22 +2729,60 @@ var ManifestReads = class {
 };
 async function manifestStamp(manifestPath) {
   try {
-    const stat = await fs5.stat(manifestPath);
+    const stat = await fs7.stat(manifestPath);
     return `${stat.ino}:${stat.mtimeMs}:${stat.size}`;
   } catch {
     return null;
   }
 }
-async function readManifest(manifestPath) {
+async function readManifest2(manifestPath) {
   try {
-    return readJsonFile(manifestPath);
+    const manifest = readJsonFile3(manifestPath);
+    return Array.isArray(manifest.shards) ? manifest : null;
   } catch {
     return null;
   }
 }
 
+// src/cacheLocation.ts
+import { createHash as createHash6 } from "crypto";
+import fs8 from "fs";
+import path9 from "path";
+var CACHE_DIR_ENV = "SUSS_CACHE_DIR";
+function chosenCacheRoot() {
+  const chosen = process.env[CACHE_DIR_ENV];
+  if (chosen === void 0 || chosen === "") {
+    return null;
+  }
+  return path9.resolve(chosen);
+}
+function realPathOrSelf(dir) {
+  try {
+    return fs8.realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+function projectKey(projectDir) {
+  return createHash6("sha256").update(realPathOrSelf(path9.resolve(projectDir))).digest("hex").slice(0, 16);
+}
+function extractionCacheDirFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return path9.join(projectDir, ".suss", "cache");
+  }
+  return path9.join(root, "cache", projectKey(projectDir));
+}
+function liveRecordFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return path9.join(projectDir, ".suss", "live", "server.json");
+  }
+  return path9.join(root, "live", `${projectKey(projectDir)}.json`);
+}
+
 // src/extractionReport.ts
-import { BOUNDARY_ROLE } from "@suss/behavioral-ir";
+import { BOUNDARY_ROLE as BOUNDARY_ROLE2 } from "@suss/behavioral-ir";
 var emptyTally = () => ({
   candidateFiles: 0,
   unitsDiscovered: 0,
@@ -2246,7 +2832,7 @@ function summaryCountsByPack(summaries) {
     }
     const entry = counts.get(recognition) ?? emptyCounts();
     entry.bound += 1;
-    if (BOUNDARY_ROLE[summary.kind] === "provider") {
+    if (BOUNDARY_ROLE2[summary.kind] === "provider") {
       entry.providers += 1;
     }
     if (summary.transitions.length > 0) {
@@ -2471,6 +3057,17 @@ function undocumentedDeclarations(gradients) {
     detail: gradient.withoutExample.join(", ")
   }));
 }
+function packConfigCheck(needs) {
+  return {
+    name: "every pack that needs an option was given it",
+    code: "no-config",
+    audience: "run",
+    violations: needs.map((need) => ({
+      label: need.pack,
+      detail: `reads nothing until ${need.option} is set, for example ${need.example}. Write that to a JSON file and pass -f ${need.pack}=<config.json>.`
+    }))
+  };
+}
 function evaluatePackHealth(report) {
   const gradients = packGradients(report);
   return [
@@ -2623,7 +3220,7 @@ function makeTransitionId(functionName, branch) {
   const { terminal } = branch;
   const statusKey = terminal.statusCode === null ? "none" : terminal.statusCode.type === "literal" ? String(terminal.statusCode.value) : `dyn:${terminal.statusCode.sourceText}`;
   const conditionSig = branch.conditions.map((c) => `${c.polarity}:${c.sourceText}`).join(";");
-  const conditionHash = createHash4("sha1").update(conditionSig).digest("hex").slice(0, 7);
+  const conditionHash = createHash7("sha1").update(conditionSig).digest("hex").slice(0, 7);
   return `${functionName}:${terminal.kind}:${statusKey}:${conditionHash}`;
 }
 function collapseReading(table, reading) {
@@ -3077,6 +3674,7 @@ function paramToInput(param) {
   };
 }
 export {
+  CACHE_DIR_ENV,
   EnclosingNodes,
   IdMap,
   IdSet,
@@ -3094,6 +3692,7 @@ export {
   assembleSummary,
   assessConfidence,
   buildUngatedExtractionReport,
+  chosenCacheRoot,
   commonDirectoryOf,
   composeWrappers,
   computeContentHash,
@@ -3101,6 +3700,7 @@ export {
   configuredCallOption,
   createAdapterStamp,
   createCacheLayer,
+  createCodeHasher,
   createPackTallies,
   createTimer,
   detectGaps,
@@ -3109,6 +3709,7 @@ export {
   enumerateOrDegrade,
   enumerateStructuredPaths,
   evaluatePackHealth,
+  extractionCacheDirFor,
   extractionConfigStamp,
   firstWrittenReading,
   formatPackHealth,
@@ -3116,6 +3717,7 @@ export {
   helperPathsOnVariables,
   httpRouteDiscovery,
   isListedTestFile,
+  liveRecordFor,
   makeIgnoredDirectory,
   makeTransitionId,
   mapReading,
@@ -3125,8 +3727,11 @@ export {
   moduleInitStructure,
   moduleOfFile,
   noopTimer,
+  ownersWhereWritten,
+  packConfigCheck,
   packGradients,
   paramToInput,
+  processCodeHasher,
   projectFileStamp,
   rawConditionToPredicate,
   recordPackFailure,