@suss/extractor 0.35.0 → 0.36.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/index.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
-  effectKey,
+  effectKey as effectKey2,
   exchangesHttpResponses as exchangesHttpResponses2,
   foldRepeatedEffects,
-  normalizeCalleeText,
+  normalizeCalleeText as normalizeCalleeText2,
   withGraphqlMetadata,
   withHttpMetadata,
   withMountMetadata,
@@ -165,6 +165,45 @@ function mergeInputReads(derived, syntactic) {
   return [...found.values()];
 }
 
+// src/callSiteGroup.ts
+import { createHash } from "crypto";
+import { effectKey, normalizeCalleeText } from "@suss/behavioral-ir";
+function callSiteKey(effect) {
+  const callee = calleeOf(effect);
+  const written = callee === void 0 ? effect : { ...effect, callee: normalizeCalleeText(callee) };
+  const hash = createHash("sha1").update(effectKey(written)).digest("hex").slice(0, 7);
+  return callee === void 0 ? hash : `${normalizeCalleeText(callee)}:${hash}`;
+}
+function calleeOf(effect) {
+  return effect.type === "interaction" || effect.type === "invocation" ? effect.callee : void 0;
+}
+function numberRepeatedCallSites(sites) {
+  const taken = /* @__PURE__ */ new Map();
+  return sites.map((entries) => {
+    const ids = /* @__PURE__ */ new Map();
+    for (const key of new Set(
+      entries.flatMap((entry) => groupIdOf(entry.effect))
+    )) {
+      const count = (taken.get(key) ?? 0) + 1;
+      taken.set(key, count);
+      ids.set(key, count === 1 ? key : `${key}#${count}`);
+    }
+    return entries.map((entry) => ({
+      ...entry,
+      effect: withGroupId(entry.effect, ids)
+    }));
+  });
+}
+function groupIdOf(effect) {
+  return effect.type === "interaction" && effect.groupId !== void 0 ? [effect.groupId] : [];
+}
+function withGroupId(effect, ids) {
+  if (effect.type !== "interaction" || effect.groupId === void 0) {
+    return effect;
+  }
+  return { ...effect, groupId: ids.get(effect.groupId) ?? effect.groupId };
+}
+
 // src/composeWrappers.ts
 import {
   exchangesHttpResponses,
@@ -472,6 +511,22 @@ function modulesStamp(modules) {
 // src/effectGuards.ts
 var keyOf = (condition) => `${condition.polarity}:${condition.sourceText}`;
 var opposite = (condition) => `${condition.polarity === "positive" ? "negative" : "positive"}:${condition.sourceText}`;
+function firesOn(site, branch) {
+  const loop = branch.loopAround;
+  if (loop !== void 0 && site.line >= loop.start && site.line <= loop.end) {
+    return true;
+  }
+  if (!guardsHoldOn(site.preconditions, branch.conditions)) {
+    return false;
+  }
+  return runsBefore(
+    site.cleansUpFrom ?? site.line,
+    branch.terminal.location.end
+  );
+}
+function effectsFiringOn(placed, branch) {
+  return placed.filter((one) => firesOn(one.site, branch)).map((one) => one.effect);
+}
 function guardsHoldOn(preconditions, conditions) {
   if (preconditions === void 0 || preconditions.length === 0) {
     return true;
@@ -539,16 +594,21 @@ function throughHelper(branch, at, helperBranches) {
         isDefault: branch.isDefault && helper.isDefault
       };
     }
+    const { loopAround, ...rest } = branch;
     return {
-      ...branch,
+      ...rest,
       ...reads,
       conditions,
       terminal: { ...helper.terminal, location: at },
       location: at,
+      ...loopAround !== void 0 && within(at, loopAround) ? { loopAround } : {},
       isDefault: false
     };
   });
 }
+function within(inner, outer) {
+  return inner.start >= outer.start && inner.end <= outer.end;
+}
 function mergeReadShapes(a, b) {
   if (a === null || b === null) {
     return a ?? b;
@@ -566,12 +626,11 @@ function mergeReadShapes(a, b) {
 function splitAtHandOffs(branch, sites, from = 0) {
   for (let index = from; index < sites.length; index++) {
     const site = sites[index];
-    const reached = site.alwaysRuns === true || runsBefore(site.line, branch.terminal.location.end);
-    if (!reached || !guardsHoldOn(site.preconditions, branch.conditions)) {
+    if (!firesOn(site, branch)) {
       continue;
     }
     return throughHelper(branch, site.at, site.helper).flatMap(
-      (path10) => path10.terminal === branch.terminal ? splitAtHandOffs(path10, sites, index + 1) : [path10]
+      (path11) => path11.terminal === branch.terminal ? splitAtHandOffs(path11, sites, index + 1) : [path11]
     );
   }
   return [branch];
@@ -618,6 +677,34 @@ function rootName(ref) {
   return ref.type === "dependency" ? ref.name : null;
 }
 
+// src/libraryEnvReads.ts
+import { functionCallBinding } from "@suss/behavioral-ir";
+function libraryEnvReadMarker(recognition, declared, importer) {
+  return {
+    kind: "library",
+    location: { file: importer, range: { start: 0, end: 0 }, exportName: null },
+    identity: {
+      name: `${declared.module} env reads`,
+      exportPath: null,
+      boundaryBinding: functionCallBinding({
+        transport: "in-process",
+        recognition
+      })
+    },
+    inputs: [],
+    transitions: [],
+    gaps: [],
+    confidence: { source: "declared", level: "high" },
+    metadata: {
+      libraryEnvReads: {
+        module: declared.module,
+        ...declared.prefixes !== void 0 ? { prefixes: declared.prefixes } : {},
+        ...declared.names !== void 0 ? { names: declared.names } : {}
+      }
+    }
+  };
+}
+
 // src/moduleImports.ts
 function stampModuleImports(summaries, importsOf2) {
   const byFile = /* @__PURE__ */ new Map();
@@ -919,8 +1006,8 @@ var catchEntryCond = () => fixedCond(
   "positive",
   "catchBlock"
 );
-function classify(path10, home, isAncestorOrSelf) {
-  return path10.map((cond) => {
+function classify(path11, home, isAncestorOrSelf) {
+  return path11.map((cond) => {
     if (cond.branchStmt === null) {
       return cond.info;
     }
@@ -992,9 +1079,9 @@ function limitOpenPaths(paths) {
     );
   }
 }
-function recordTerminal(ctx, terminal, home, path10) {
+function recordTerminal(ctx, terminal, home, path11) {
   chargeBudget(ctx.state);
-  const info = classify(path10, home, ctx.isAncestorOrSelf);
+  const info = classify(path11, home, ctx.isAncestorOrSelf);
   const existing = ctx.state.byTerminal.get(terminal) ?? [];
   existing.push(info);
   ctx.state.byTerminal.set(terminal, existing);
@@ -1005,15 +1092,15 @@ function containsTerminal(ctx, stmt) {
   }
   return childrenOf(stmt).some((child) => containsTerminal(ctx, child));
 }
-function stepIf(stmt, path10, ctx) {
+function stepIf(stmt, path11, ctx) {
   const thenExit = exitKindOfList(stmt.thenBody);
   const elseExit = stmt.elseBody === null ? null : exitKindOfList(stmt.elseBody);
   const thenPath = [
-    ...path10,
+    ...path11,
     branchCond(stmt, stmt.condition, "positive", elseExit)
   ];
   const elsePath = [
-    ...path10,
+    ...path11,
     branchCond(
       stmt,
       stmt.condition,
@@ -1030,7 +1117,7 @@ function stepIf(stmt, path10, ctx) {
   }
   return out;
 }
-function stepSwitch(stmt, path10, ctx) {
+function stepSwitch(stmt, path11, ctx) {
   const out = [];
   const negations = [];
   let defaultRanBody = false;
@@ -1040,7 +1127,7 @@ function stepSwitch(stmt, path10, ctx) {
     if (hasStrayBreak(group.body)) {
       throw new UnmodeledFlow("non-trailing break in switch clause");
     }
-    const groupPath = group.condition === null ? [...path10, ...negations] : [...path10, fixedCond(group.condition, "positive", "explicit")];
+    const groupPath = group.condition === null ? [...path11, ...negations] : [...path11, fixedCond(group.condition, "positive", "explicit")];
     const conts = enumerate(ctx, group.body, groupPath);
     if (conts.length > 0) {
       if (!group.hasTrailingBreak && !fallthroughSafe) {
@@ -1057,24 +1144,24 @@ function stepSwitch(stmt, path10, ctx) {
     }
   }
   if (!defaultRanBody) {
-    out.push([...path10, ...negations]);
+    out.push([...path11, ...negations]);
   }
   return out;
 }
-function stepLoop(stmt, path10, ctx) {
+function stepLoop(stmt, path11, ctx) {
   const bodyExit = exitKindOfList(stmt.body);
   if (containsTerminal(ctx, stmt)) {
     enumerate(ctx, stmt.body, [
-      ...path10,
+      ...path11,
       loopIterationCond(stmt.condition.sourceText)
     ]);
   }
   if (bodyExit !== null) {
-    return [[...path10, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
+    return [[...path11, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
   }
-  return [path10];
+  return [path11];
 }
-function stepTry(stmt, path10, ctx) {
+function stepTry(stmt, path11, ctx) {
   if (stmt.finallyBody !== null) {
     const finallyHasTerminal = stmt.finallyBody.some(
       (s) => containsTerminal(ctx, s)
@@ -1084,22 +1171,22 @@ function stepTry(stmt, path10, ctx) {
     }
   }
   const out = [];
-  out.push(...enumerate(ctx, stmt.tryBody, path10));
+  out.push(...enumerate(ctx, stmt.tryBody, path11));
   if (stmt.catchBody !== null) {
-    const catchPath = [...path10, catchEntryCond()];
+    const catchPath = [...path11, catchEntryCond()];
     out.push(...enumerate(ctx, stmt.catchBody, catchPath));
   }
   return out;
 }
-function stepExit(stmt, path10, ctx) {
+function stepExit(stmt, path11, ctx) {
   const collector = ctx.state.callbackExits[ctx.state.callbackExits.length - 1];
   if (collector !== void 0 && (stmt.exit === "return" || stmt.exit === "throw")) {
-    collector.push(path10);
+    collector.push(path11);
   }
   return [];
 }
-function stepOpaque(_stmt, path10, _ctx) {
-  return [path10];
+function stepOpaque(_stmt, path11, _ctx) {
+  return [path11];
 }
 var stepHandlers = {
   if: stepIf,
@@ -1109,20 +1196,20 @@ var stepHandlers = {
   exit: stepExit,
   opaque: stepOpaque
 };
-function stepCallback(ctx, body, path10) {
+function stepCallback(ctx, body, path11) {
   const exits = [];
   ctx.state.callbackExits.push(exits);
   let fellThrough;
   try {
-    fellThrough = enumerate(ctx, body, path10);
+    fellThrough = enumerate(ctx, body, path11);
   } finally {
     ctx.state.callbackExits.pop();
   }
   const out = [...fellThrough, ...exits];
-  return out.length === 0 ? [path10] : out;
+  return out.length === 0 ? [path11] : out;
 }
-function stepStatement(ctx, stmt, path10) {
-  let paths = [path10];
+function stepStatement(ctx, stmt, path11) {
+  let paths = [path11];
   for (const body of stmt.callbacks ?? []) {
     paths = paths.flatMap((each) => stepCallback(ctx, body, each));
     limitOpenPaths(paths);
@@ -1209,8 +1296,8 @@ function enumerate(ctx, stmts, prefix) {
   let frontiers = [[...prefix]];
   for (const stmt of stmts) {
     const nextFrontiers = [];
-    for (const path10 of mergeRejoined(frontiers, ctx.keepsArms)) {
-      nextFrontiers.push(...stepStatement(ctx, stmt, path10));
+    for (const path11 of mergeRejoined(frontiers, ctx.keepsArms)) {
+      nextFrontiers.push(...stepStatement(ctx, stmt, path11));
     }
     frontiers = nextFrontiers;
     limitOpenPaths(frontiers);
@@ -1234,6 +1321,39 @@ function buildParentMap(statements) {
   }
   return parentOf;
 }
+function placeTerminals(input, parentOf = buildParentMap(input.statements)) {
+  const placement = /* @__PURE__ */ new Map();
+  for (const [home, terminals] of input.terminalsByStmt) {
+    const placed = placementOf(home, parentOf);
+    if (placed.loopAround === void 0 && placed.cleansUpFrom === void 0) {
+      continue;
+    }
+    for (const terminal of terminals) {
+      placement.set(terminal, placed);
+    }
+  }
+  return placement;
+}
+function placementOf(home, parentOf) {
+  let loopAround = home.kind === "loop" ? home.lines : void 0;
+  let cleansUpFrom;
+  let child = home;
+  let parent = parentOf.get(home) ?? null;
+  while (parent !== null) {
+    if (parent.kind === "loop" && parent.lines !== void 0) {
+      loopAround = parent.lines;
+    }
+    if (parent.kind === "try" && parent.lines !== void 0 && (parent.finallyBody ?? []).includes(child)) {
+      cleansUpFrom = parent.lines.start;
+    }
+    child = parent;
+    parent = parentOf.get(parent) ?? null;
+  }
+  return {
+    ...loopAround === void 0 ? {} : { loopAround: { start: loopAround.start, end: loopAround.end } },
+    ...cleansUpFrom === void 0 ? {} : { cleansUpFrom }
+  };
+}
 function enumerateStructuredPaths(input) {
   const parentOf = buildParentMap(input.statements);
   const isAncestorOrSelf = (a, b) => {
@@ -1259,11 +1379,15 @@ function enumerateStructuredPaths(input) {
     isAncestorOrSelf
   };
   const continuations = withRejoined(enumerate(ctx, input.statements, []));
-  for (const path10 of continuations) {
+  for (const path11 of continuations) {
     chargeBudget(state);
-    state.fallthrough.push(classify(path10, null, isAncestorOrSelf));
+    state.fallthrough.push(classify(path11, null, isAncestorOrSelf));
   }
-  return { byTerminal: state.byTerminal, fallthrough: state.fallthrough };
+  return {
+    byTerminal: state.byTerminal,
+    fallthrough: state.fallthrough,
+    placement: placeTerminals(input, parentOf)
+  };
 }
 function enumerateOrDegrade(input, terminals) {
   try {
@@ -1283,9 +1407,28 @@ function enumerateOrDegrade(input, terminals) {
     for (const terminal of terminals) {
       byTerminal.set(terminal, [[marker]]);
     }
-    return { byTerminal, fallthrough: [[marker]], degraded: reason };
+    return {
+      byTerminal,
+      fallthrough: [[marker]],
+      placement: placeTerminals(input),
+      degraded: reason
+    };
   }
 }
+function enumerateCallStatements(input, terminals) {
+  const placement = placeTerminals(input);
+  const enumerable = new Map(
+    [...input.terminalsByStmt].filter(
+      ([, found]) => found.every(
+        (terminal) => placement.get(terminal)?.cleansUpFrom === void 0
+      )
+    )
+  );
+  return {
+    ...enumerateOrDegrade({ ...input, terminalsByStmt: enumerable }, terminals),
+    placement
+  };
+}
 function reasonToDegrade(error) {
   if (error instanceof PathBudgetExceeded) {
     return error.message === "" ? "path budget exceeded" : error.message;
@@ -1304,8 +1447,8 @@ function sharedGatingConditions(paths, readPredicate) {
     return [];
   }
   const shared = new Set(first.map(keyOf2));
-  for (const path10 of rest) {
-    const here = new Set(path10.map(keyOf2));
+  for (const path11 of rest) {
+    const here = new Set(path11.map(keyOf2));
     for (const value of shared) {
       if (!here.has(value)) {
         shared.delete(value);
@@ -1423,6 +1566,43 @@ function walkDescendants(root, carried, childrenOf2, visitor) {
   }
 }
 
+// src/paths/statementSites.ts
+function statementSites(nodes, reading) {
+  const statements = new IdMap();
+  const statementOfNode = new IdMap();
+  for (const node of nodes) {
+    const written = reading.statementOf(node);
+    if (written === null) {
+      continue;
+    }
+    const statement = statements.get(written) ?? written;
+    statements.set(statement, statement);
+    statementOfNode.set(node, statement);
+  }
+  const terminals = [...statements].map(([statement]) => statement);
+  const enumerated = enumerateCallStatements(
+    reading.lower(terminals),
+    terminals
+  );
+  const pathsTo = (node) => {
+    const statement = statementOfNode.get(node);
+    return statement === void 0 ? void 0 : enumerated.byTerminal.get(statement);
+  };
+  const siteOf = (node, preconditions) => {
+    const statement = statementOfNode.get(node);
+    return {
+      line: reading.firstLine(statement ?? node),
+      preconditions,
+      cleansUpFrom: statement === void 0 ? void 0 : enumerated.placement.get(statement)?.cleansUpFrom
+    };
+  };
+  return {
+    pathsTo,
+    siteOf,
+    plainSiteOf: (node) => siteOf(node, sharedGatingConditions(pathsTo(node)))
+  };
+}
+
 // src/projectRoot.ts
 import path3 from "path";
 function commonDirectoryOf(files) {
@@ -1571,13 +1751,13 @@ function quoted(text, key) {
 }
 
 // src/adapterStamp.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import fs3 from "fs";
 import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/codeHash.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import fs2 from "fs";
 import { createRequire } from "module";
 import path4 from "path";
@@ -1623,7 +1803,7 @@ function createCodeHasher() {
     if (files.length === 0) {
       return "";
     }
-    const hash = createHash("sha256");
+    const hash = createHash2("sha256");
     for (const file of files) {
       hash.update(read.get(file)?.digest ?? "");
     }
@@ -1640,7 +1820,7 @@ function readCodeFile(file) {
     return null;
   }
   return {
-    digest: createHash("sha256").update(text).digest("hex"),
+    digest: createHash2("sha256").update(text).digest("hex"),
     imports: importsOf(file, text.toString("utf8"))
   };
 }
@@ -1798,7 +1978,7 @@ function computeContentHash(paths) {
   if (paths.length === 0) {
     return "";
   }
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   for (const file of paths) {
     try {
       hash.update(fs3.readFileSync(file));
@@ -1812,7 +1992,7 @@ function projectFileStamp(paths) {
   if (paths.length === 0) {
     return "none";
   }
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   for (const file of [...paths].sort()) {
     hash.update(file);
     hash.update("\0");
@@ -1847,7 +2027,7 @@ function runDigest(packsDigest, packs, files) {
 }
 
 // src/cache.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import fs7 from "fs/promises";
 import path8 from "path";
 import { readJsonFile as readJsonFile3, writeDocumentFile as writeDocumentFile2 } from "@suss/behavioral-ir/files";
@@ -1955,7 +2135,7 @@ function keyOf3(binding) {
 }
 
 // src/cacheShards.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import fs4 from "fs";
 import path6 from "path";
 import {
@@ -2021,7 +2201,7 @@ function namesIn(dir) {
 }
 function writeOnce(root, value) {
   const pieces = [...documentPieces(value)];
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const piece of pieces) {
     hash.update(piece);
   }
@@ -2125,7 +2305,7 @@ function copyOfJson(value) {
 }
 
 // src/cacheStamps.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import fs5 from "fs/promises";
 var RECENT_CHANGE_MS = 2e3;
 function stampMayMissAWrite(stat, statAt) {
@@ -2215,7 +2395,7 @@ function reusableHash(prior, stamp) {
 async function hashFile(filePath) {
   try {
     const content = await fs5.readFile(filePath);
-    return createHash4("sha256").update(content).digest("hex").slice(0, 16);
+    return createHash5("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return null;
   }
@@ -2671,7 +2851,7 @@ function entryDirFor(cacheDir, input) {
     input.adapterPacksDigest,
     input.configPath ?? ""
   ].join(" ");
-  const name = createHash5("sha256").update(key).digest("hex").slice(0, 16);
+  const name = createHash6("sha256").update(key).digest("hex").slice(0, 16);
   return path8.join(cacheDir, `${ENTRY_PREFIX}${name}`);
 }
 function isEntryDir(name) {
@@ -2745,7 +2925,7 @@ async function readManifest2(manifestPath) {
 }
 
 // src/cacheLocation.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 var CACHE_DIR_ENV = "SUSS_CACHE_DIR";
@@ -2764,7 +2944,7 @@ function realPathOrSelf(dir) {
   }
 }
 function projectKey(projectDir) {
-  return createHash6("sha256").update(realPathOrSelf(path9.resolve(projectDir))).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(realPathOrSelf(path9.resolve(projectDir))).digest("hex").slice(0, 16);
 }
 function extractionCacheDirFor(projectDir) {
   const root = chosenCacheRoot();
@@ -2773,6 +2953,13 @@ function extractionCacheDirFor(projectDir) {
   }
   return path9.join(root, "cache", projectKey(projectDir));
 }
+function mapFolderFor(projectDir) {
+  const root = chosenCacheRoot();
+  if (root === null) {
+    return path9.join(projectDir, ".suss");
+  }
+  return path9.join(root, "map", projectKey(projectDir));
+}
 function liveRecordFor(projectDir) {
   const root = chosenCacheRoot();
   if (root === null) {
@@ -2921,6 +3108,7 @@ var KeptParses = class {
 };
 
 // src/packHealth.ts
+import path10 from "path";
 function stagesOf(funnel) {
   const stages = [];
   const gateSaysSomething = funnel.gates.length > 0 && funnel.unresolvedGates.length === 0;
@@ -3068,6 +3256,30 @@ function packConfigCheck(needs) {
     }))
   };
 }
+function describeMissingPath(missing) {
+  const where = `${missing.option} is ${missing.value} in ${missing.configFile}`;
+  if (path10.isAbsolute(missing.value)) {
+    return {
+      problem: `${where}, and nothing exists there.`,
+      fix: `Set ${missing.option} to a path that exists.`
+    };
+  }
+  return {
+    problem: `${where}, and nothing exists at ${missing.resolved}. A relative path is read against the config file, not the project.`,
+    fix: missing.inProject === void 0 ? `Set ${missing.option} to an absolute path, or move the config file into the project.` : `Set ${missing.option} to ${missing.inProject} in the config file, or move the config file into the project.`
+  };
+}
+function packPathCheck(missing) {
+  return {
+    name: "every path a pack config gives exists",
+    code: "no-path",
+    audience: "run",
+    violations: missing.map((one) => {
+      const { problem, fix } = describeMissingPath(one);
+      return { label: one.pack, detail: `${problem} ${fix}` };
+    })
+  };
+}
 function evaluatePackHealth(report) {
   const gradients = packGradients(report);
   return [
@@ -3220,7 +3432,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 = createHash7("sha1").update(conditionSig).digest("hex").slice(0, 7);
+  const conditionHash = createHash8("sha1").update(conditionSig).digest("hex").slice(0, 7);
   return `${functionName}:${terminal.kind}:${statusKey}:${conditionHash}`;
 }
 function collapseReading(table, reading) {
@@ -3295,11 +3507,11 @@ function provenanceOf(raw, effects) {
   if (raw.length === 0) {
     return [];
   }
-  const positionOf = new Map(effects.map((one, at) => [effectKey(one), at]));
+  const positionOf = new Map(effects.map((one, at) => [effectKey2(one), at]));
   const bySlot = /* @__PURE__ */ new Map();
   const said = /* @__PURE__ */ new Map();
   for (const one of raw) {
-    const effect = positionOf.get(effectKey(withNormalizedCallee(one.effect)));
+    const effect = positionOf.get(effectKey2(withNormalizedCallee(one.effect)));
     if (effect === void 0) {
       continue;
     }
@@ -3331,7 +3543,7 @@ function withNormalizedCallee(effect) {
   if (effect.callee === void 0) {
     return effect;
   }
-  return { ...effect, callee: normalizeCalleeText(effect.callee) };
+  return { ...effect, callee: normalizeCalleeText2(effect.callee) };
 }
 function assembleSummary(raw, options = DEFAULT_OPTIONS) {
   const transitions = raw.branches.map((rawBranch) => {
@@ -3419,6 +3631,9 @@ function buildMetadata(raw) {
   if (raw.test !== void 0) {
     metadata = withTestMetadata(metadata, raw.test);
   }
+  if (raw.packMetadata !== void 0) {
+    metadata = { ...metadata, ...raw.packMetadata };
+  }
   return Object.keys(metadata).length > 0 ? metadata : null;
 }
 function buildHttpMetadataValue(raw) {
@@ -3470,6 +3685,12 @@ function buildGraphqlMetadataValue(raw) {
   if (raw.graphqlUnresolvedDocument !== void 0) {
     graphql.unresolvedDocument = raw.graphqlUnresolvedDocument;
   }
+  if (raw.graphqlClient !== void 0) {
+    graphql.client = raw.graphqlClient;
+  }
+  if (raw.graphqlUnresolvedClient !== void 0) {
+    graphql.unresolvedClient = raw.graphqlUnresolvedClient;
+  }
   return Object.keys(graphql).length > 0 ? graphql : null;
 }
 function answersWithHttpResponses(raw) {
@@ -3661,7 +3882,10 @@ var effectConverters = {
   stateChange: (e) => ({ type: "stateChange", variable: e.variable })
 };
 function effectToIR(effect) {
-  return effectConverters[effect.type](effect);
+  const converted = effectConverters[effect.type](
+    effect
+  );
+  return effect.location === void 0 ? converted : { ...converted, location: effect.location };
 }
 function paramToInput(param) {
   return {
@@ -3692,6 +3916,7 @@ export {
   assembleSummary,
   assessConfidence,
   buildUngatedExtractionReport,
+  callSiteKey,
   chosenCacheRoot,
   commonDirectoryOf,
   composeWrappers,
@@ -3703,23 +3928,28 @@ export {
   createCodeHasher,
   createPackTallies,
   createTimer,
+  describeMissingPath,
   detectGaps,
   effectToIR,
+  effectsFiringOn,
   emptyTally,
   enumerateOrDegrade,
   enumerateStructuredPaths,
   evaluatePackHealth,
   extractionCacheDirFor,
   extractionConfigStamp,
+  firesOn,
   firstWrittenReading,
   formatPackHealth,
   guardsHoldOn,
   helperPathsOnVariables,
   httpRouteDiscovery,
   isListedTestFile,
+  libraryEnvReadMarker,
   liveRecordFor,
   makeIgnoredDirectory,
   makeTransitionId,
+  mapFolderFor,
   mapReading,
   markReturnsAsExitCode,
   matchesTestFileName,
@@ -3727,10 +3957,13 @@ export {
   moduleInitStructure,
   moduleOfFile,
   noopTimer,
+  numberRepeatedCallSites,
   ownersWhereWritten,
   packConfigCheck,
   packGradients,
+  packPathCheck,
   paramToInput,
+  placeTerminals,
   processCodeHasher,
   projectFileStamp,
   rawConditionToPredicate,
@@ -3748,6 +3981,7 @@ export {
   stampMayMissAWrite,
   stampModuleImports,
   stampModules,
+  statementSites,
   storageSystemOption,
   summaryCountsByPack,
   tallyUnit,