@suss/resolution 0.34.1 → 0.35.1

package/dist/index.js

@@ -17,6 +17,7 @@ var ASKING_RELATIONS = [
   "wantedEnvObject",
   "wantedStreamObject",
   "wantedExitSink",
+  "wantedDispatch",
   "wantedOrigin",
   "wantedCallOrigin",
   "wantedExportsOf",
@@ -534,6 +535,29 @@ function classMemberOf(name) {
   return name.startsWith(CLASS_MEMBER_PREFIX) ? name.slice(CLASS_MEMBER_PREFIX.length) : null;
 }
 
+// src/valuePositions.ts
+var VALUE_ENTRY = "value";
+var SPREAD_ENTRY = "spread";
+function addEntryRows(add, container, entries) {
+  entries.forEach((entry, position) => {
+    add("writtenEntryAt", [container, String(position), entry.key, entry.form]);
+  });
+}
+function addTemplateRows(add, template, pieces) {
+  let position = 0;
+  for (const piece of pieces) {
+    if ("hole" in piece) {
+      add("holeAt", [template, String(position), piece.hole]);
+      position += 1;
+      continue;
+    }
+    if (piece.text !== "") {
+      add("partAt", [template, String(position), piece.text]);
+      position += 1;
+    }
+  }
+}
+
 // src/contract.ts
 var distinct = (values) => new Set(values).size;
 function leadsToOneOf(facts, key, targets) {
@@ -551,6 +575,30 @@ function leadsToOneOf(facts, key, targets) {
   return false;
 }
 var RELATIONS_THAT_CAN_CROSS = ["imports", "binds", "reExports"];
+function someValueLeadsTo(facts, key) {
+  const target = /* @__PURE__ */ new Set([key]);
+  return ["returnsValue", "holdsUnderKey"].some(
+    (relation) => facts(relation).some((row) => leadsToOneOf(facts, row[1] ?? "", target))
+  );
+}
+function holdsValueThenSpread(facts, name) {
+  const entries = facts("writtenEntryAt");
+  const held = facts("holdsProperty");
+  return [...new Set(entries.map((row) => row[0]))].some((container) => {
+    const own = entries.filter((row) => row[0] === container);
+    const value = own.find((row) => row[1] === "0");
+    const spread2 = own.find((row) => row[1] === "1");
+    return own.length === 2 && value?.[3] === VALUE_ENTRY && spread2?.[3] === SPREAD_ENTRY && held.some(
+      (row) => row[0] === container && row[1] === name && row[2] === value[2]
+    ) && !held.some((row) => row[0] === container && row[2] === spread2[2]);
+  });
+}
+function valueThenSpread(facts, name) {
+  if (facts("writtenEntryAt").length === 0) {
+    return "no list or object states its entries, so nothing says the order they are written in";
+  }
+  return holdsValueThenSpread(facts, name) ? null : `no container's entries are the value under ${name} at 0, keyed as holdsProperty keys it, and then a spread at 1 keyed on the collection it unpacks`;
+}
 var FACT_CONTRACT_CASES = [
   {
     name: "two functions, one parameter name",
@@ -749,6 +797,122 @@ var FACT_CONTRACT_CASES = [
       return stores.some((row) => leadsToOneOf(facts, row[0] ?? "", sites)) ? null : "the write is keyed so that nothing leads from it to the construction, so the rules cannot find the object it lands on";
     }
   },
+  {
+    name: "a table of functions called by a key worked out at run time",
+    requires: "a module-level table written out with a function under the name created and another under deleted, and a function that calls the table's entry under its parameter, `TABLE[kind](payload)` or the language's own spelling",
+    // The rules take the entries off the object the read's container
+    // leads to, so the container has to be keyed the way `binds` keys it,
+    // and each entry under the name the source writes, without quotes.
+    check: (facts) => {
+      const entries = facts("holdsProperty");
+      const tables = new Set(
+        entries.filter((row) => row[1] === "created").map((row) => row[0] ?? "").filter(
+          (table) => entries.some((row) => row[0] === table && row[1] === "deleted")
+        )
+      );
+      if (tables.size === 0) {
+        return "no object contains a function under created and another under deleted, written without quotes";
+      }
+      const reads = facts("choosesEntry");
+      if (reads.length === 0) {
+        return "the read at a key worked out at run time is not written down as choosesEntry, so no call through it finds the table's functions";
+      }
+      return reads.some((row) => leadsToOneOf(facts, row[1] ?? "", tables)) ? null : "the read's container is keyed so that nothing leads from it to the table";
+    }
+  },
+  {
+    name: "a function written into a table under a computed key",
+    requires: "a module-level empty table, and a function that writes its second parameter into it under its first, `REGISTRY[name] = handler` or the language's own spelling",
+    // A registry fills its table from a function its callers pass handlers
+    // to, so the write has to say the parameter went in, keyed so that
+    // `binds` leads from where it went to the table.
+    check: (facts) => {
+      const params = new Set(facts("paramOf").map((row) => row[2] ?? ""));
+      const writes = facts("holdsUnderKey").filter(
+        (row) => leadsToOneOf(facts, row[1] ?? "", params)
+      );
+      if (writes.length === 0) {
+        return "the write of a parameter into a table under a computed key is not written down as holdsUnderKey";
+      }
+      const objects = new Set(facts("objectValue").map((row) => row[0] ?? ""));
+      return writes.some((row) => leadsToOneOf(facts, row[0] ?? "", objects)) ? null : "the write is keyed so that nothing leads from it to the table";
+    }
+  },
+  {
+    name: "a list written with a spread",
+    requires: "a module-level name assigned a written-out list of a name and then a spread of another name, `[first, ...rest]` or the language's own spelling",
+    check: (facts) => valueThenSpread(facts, "0")
+  },
+  {
+    name: "an object written with a spread",
+    requires: "a module-level name assigned an object or a dictionary written out with a name under the key a, written as a string where the language writes keys that way, and then a spread of another name",
+    check: (facts) => valueThenSpread(facts, "a")
+  },
+  {
+    name: "a template string with a hole",
+    requires: "a module-level name assigned the result of a call, and a template string that puts that name between two pieces of text, `/users/${id}/posts` or the language's own spelling",
+    check: (facts) => {
+      const parts = facts("partAt");
+      const [hole, ...moreHoles] = facts("holeAt");
+      if (parts.length !== 2 || hole === void 0 || moreHoles.length > 0) {
+        return `expected two parts and one hole, found ${parts.length} and ${moreHoles.length + (hole === void 0 ? 0 : 1)}`;
+      }
+      const positions = [...parts, hole].filter((row) => row[0] === hole[0]).map((row) => row[1]).sort();
+      if (positions.join() !== "0,1,2" || hole[1] !== "1") {
+        return "the parts and the hole of one template are not numbered together in source order from 0";
+      }
+      const calls = new Set(facts("call").map((row) => row[0] ?? ""));
+      return leadsToOneOf(facts, hole[2] ?? "", calls) ? null : "the hole is keyed so that nothing leads from it to the value the name is given";
+    }
+  },
+  {
+    name: "a callback given each element of a list",
+    requires: "a function that maps its parameter through a callback returning the element it is given, `users.map((user) => user)`, a comprehension or the language's own spelling",
+    // The collection is a read of the function's parameter, and the
+    // callback's own read of its variable joins the key elementOf states.
+    check: (facts) => {
+      const [row, ...more] = facts("elementOf");
+      if (row === void 0 || more.length > 0) {
+        return `expected one elementOf row, found ${more.length + (row === void 0 ? 0 : 1)}`;
+      }
+      const params = new Set(facts("paramOf").map((one) => one[2] ?? ""));
+      if (!leadsToOneOf(facts, row[1] ?? "", params)) {
+        return "the collection is keyed so that nothing leads from it to the parameter it reads";
+      }
+      return someValueLeadsTo(facts, row[0] ?? "") ? null : "no read of the variable leads to the key elementOf gives it, so nothing knows what the read is given";
+    }
+  },
+  {
+    name: "a callback given the parts of each element of a list",
+    requires: "a function that maps its parameter through a callback taking each element apart into two names and returning the first, `pairs.map(([name, kind]) => name)`, `[name for name, kind in pairs]` or the language's own spelling",
+    check: (facts) => {
+      const parts = facts("elementPartOf");
+      const first = parts.find((row) => row[2] === "0");
+      const second = parts.find((row) => row[2] === "1");
+      if (first === void 0 || second === void 0) {
+        return "no two names are given parts 0 and 1 of each element, so nothing says what a name taken apart is given";
+      }
+      const params = new Set(facts("paramOf").map((one) => one[2] ?? ""));
+      if (first[1] !== second[1] || !leadsToOneOf(facts, first[1] ?? "", params)) {
+        return "the two parts name different collections, or one that nothing leads from to the parameter it reads";
+      }
+      return someValueLeadsTo(facts, first[0] ?? "") ? null : "no read of the first name leads to the key elementPartOf gives it";
+    }
+  },
+  {
+    name: "a callback given each position in a list",
+    requires: "a function that maps its parameter through a callback taking the element and then its position and returning the position, `users.map((user, at) => at)`, `enumerate` in a comprehension, or the language's own spelling",
+    check: (facts) => {
+      const [row, ...more] = facts("positionOf");
+      if (row === void 0 || more.length > 0) {
+        return `expected one positionOf row, found ${more.length + (row === void 0 ? 0 : 1)}`;
+      }
+      if (!facts("elementOf").some((one) => one[0] === row[1])) {
+        return "the position is tied to a variable that no elementOf row gives an element, so nothing says what it counts through";
+      }
+      return someValueLeadsTo(facts, row[0] ?? "") ? null : "no read of the position leads to the key positionOf gives it";
+    }
+  },
   {
     name: "a value another file declares",
     requires: "two files, one declaring a value and the other reading it by name",
@@ -1151,13 +1315,13 @@ var FactLog = class {
   hashesByKey(relation, row) {
     const hashes = /* @__PURE__ */ new Map();
     const atoms = row.map((atom) => this.hashesOf(String(atom)));
-    const term = (hash, column) => spread(hash + Math.imul(column + 1, 2654435761) >>> 0);
+    const term = (hash, column2) => spread(hash + Math.imul(column2 + 1, 2654435761) >>> 0);
     let loose = hashString(relation);
-    atoms.forEach((atom, column) => {
-      loose = loose + term(atom.loose, column) >>> 0;
+    atoms.forEach((atom, column2) => {
+      loose = loose + term(atom.loose, column2) >>> 0;
     });
-    atoms.forEach((atom, column) => {
-      const key = String(row[column]);
+    atoms.forEach((atom, column2) => {
+      const key = String(row[column2]);
       if (!atom.key || hashes.has(key)) {
         return;
       }
@@ -1254,6 +1418,107 @@ var FactLog = class {
   }
 };
 
+// src/dispatch.ts
+function dispatchOutcomes(db, calls, program = resolutionProgram()) {
+  const outcomes = /* @__PURE__ */ new Map();
+  if (calls.length === 0) {
+    return outcomes;
+  }
+  askResolution(db, calls, DISPATCH_QUESTION, program);
+  return readDispatchOutcomes(db, calls);
+}
+var DISPATCH_QUESTION = "wantedDispatch";
+function readDispatchOutcomes(db, calls) {
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const call of new Set(calls)) {
+    const sites = column(db, "wantedDispatchSite", call, 1);
+    if (sites.length === 0) {
+      continue;
+    }
+    outcomes.set(call, outcomeOf(db, call, sites));
+  }
+  return outcomes;
+}
+function outcomeOf(db, call, sites) {
+  const byEntry = /* @__PURE__ */ new Map();
+  for (const entry of column(db, "wantedDispatchEntry", call, 1)) {
+    byEntry.set(entry, /* @__PURE__ */ new Set());
+  }
+  for (const row of db.lookup("wantedDispatchLikeEntry", 0, call)) {
+    const held = String(row[3]);
+    if (!byEntry.has(held) && matchesWrittenPart(db, String(row[1]), String(row[2]))) {
+      byEntry.set(held, /* @__PURE__ */ new Set());
+    }
+  }
+  for (const relation of ENTRY_FUNCTIONS) {
+    for (const row of db.lookup(relation, 0, call)) {
+      byEntry.get(String(row[1]))?.add(String(row[2]));
+    }
+  }
+  const functions = [
+    ...new Set([...byEntry.values()].flatMap((found) => [...found]))
+  ];
+  const unresolved = [...byEntry.values()].filter(
+    (found) => found.size === 0
+  ).length;
+  const through = /* @__PURE__ */ new Map();
+  for (const row of db.lookup("wantedDispatchThrough", 0, call)) {
+    const inner = through.get(String(row[1])) ?? [];
+    inner.push(String(row[2]));
+    through.set(String(row[1]), inner);
+  }
+  return {
+    functions,
+    certain: functions.length === 1 && unresolved === 0 && narrowedToOneName(db, sites) && column(db, "wantedDispatchComputed", call, 1).length === 0 && column(db, "wantedDispatchInBranch", call, 1).length === 0,
+    unresolved,
+    through,
+    containers: [
+      ...new Set(
+        sites.flatMap(
+          (site) => ENTRY_READS.flatMap((relation) => column(db, relation, site, 1))
+        )
+      )
+    ]
+  };
+}
+var ENTRY_READS = [
+  "choosesEntry",
+  "choosesNamedEntry",
+  "choosesEntryLike",
+  "readsEntry"
+];
+var ENTRY_FUNCTIONS = [
+  "wantedDispatchFunction",
+  "wantedDispatchLikeFunction"
+];
+function matchesWrittenPart(db, site, name) {
+  return db.lookup("choosesEntryLike", 0, site).some((row) => {
+    const prefix = String(row[2]);
+    const suffix = String(row[3]);
+    return name.length >= prefix.length + suffix.length && name.startsWith(prefix) && name.endsWith(suffix);
+  });
+}
+function narrowedToOneName(db, sites) {
+  const names = /* @__PURE__ */ new Set();
+  for (const site of sites) {
+    if (db.lookup("choosesEntry", 0, site).length > 0) {
+      return false;
+    }
+    for (const relation of NAMED_READS) {
+      for (const row of db.lookup(relation, 0, site)) {
+        names.add(String(row[2]));
+      }
+    }
+  }
+  return names.size === 1;
+}
+var NAMED_READS = ["choosesNamedEntry", "readsEntry"];
+function column(db, relation, key, at) {
+  return [
+    ...new Set(db.lookup(relation, 0, key).map((row) => String(row[at])))
+  ];
+}
+
 // src/entryReuse.ts
 function fileOfKey(key) {
   return key.slice(0, key.lastIndexOf(":"));
@@ -1783,14 +2048,21 @@ var SPAN_KEY = /^(.*):(\d+)-(\d+)$/;
 function spanFileOf(key) {
   return key.match(SPAN_KEY)?.[1] ?? null;
 }
-function nodeOfKey(rootsByFile, key) {
+function spanOfKey(key) {
   const span = key.match(SPAN_KEY);
+  return span === null ? null : {
+    file: span[1],
+    start: Number(span[2]),
+    end: Number(span[3])
+  };
+}
+function nodeOfKey(rootsByFile, key) {
+  const span = spanOfKey(key);
   if (span === null) {
     return null;
   }
-  const root = rootsByFile.get(span[1]);
-  const start = Number(span[2]);
-  const end = Number(span[3]);
+  const root = rootsByFile.get(span.file);
+  const { start, end } = span;
   if (root === void 0 || end <= start) {
     return null;
   }
@@ -2361,6 +2633,165 @@ var STEP_LATTICE = [
   { soFar: RESULT_STEP, next: INSTANCE_STEP, took: RESULT_STEP },
   { soFar: RESULT_STEP, next: RESULT_STEP, took: RESULT_STEP }
 ];
+var DISPATCH_RULES = [
+  rule2(
+    "entryRead",
+    [v2("site"), v2("o")],
+    [lit2("choosesEntry", v2("site"), v2("o"))]
+  ),
+  rule2(
+    "entryRead",
+    [v2("site"), v2("o")],
+    [lit2("namedEntryRead", v2("site"), v2("o"), v2("n"))]
+  ),
+  rule2(
+    "entryRead",
+    [v2("site"), v2("o")],
+    [lit2("choosesEntryLike", v2("site"), v2("o"), v2("p"), v2("s"))]
+  ),
+  // Every entry of a read whose key is partly written out, by name. A rule
+  // cannot compare strings, so dispatch.ts keeps the names that match, and
+  // these stay out of `dispatchesTo`.
+  rule2(
+    "likeEntryAt",
+    [v2("site"), v2("n"), v2("held")],
+    [
+      lit2("choosesEntryLike", v2("site"), v2("o"), v2("p"), v2("s")),
+      lit2("containerOf", v2("o"), v2("obj")),
+      lit2("contains", v2("obj"), v2("n"), v2("held"))
+    ]
+  ),
+  rule2(
+    "namedEntryRead",
+    [v2("site"), v2("o"), v2("n")],
+    [lit2("choosesNamedEntry", v2("site"), v2("o"), v2("n"))]
+  ),
+  rule2(
+    "namedEntryRead",
+    [v2("site"), v2("o"), v2("n")],
+    [lit2("readsEntry", v2("site"), v2("o"), v2("n"))]
+  ),
+  // The container a read takes its entry from: an object written out, or
+  // a collection the program fills through its methods.
+  rule2("containerOf", [v2("o"), v2("obj")], [lit2("objectOf", v2("o"), v2("obj"))]),
+  rule2(
+    "containerOf",
+    [v2("o"), v2("c")],
+    [
+      lit2("reaches", v2("o"), v2("c"), VALUE_STEP),
+      lit2("collectionValue", v2("c"))
+    ]
+  ),
+  rule2("containerOf", [v2("c"), v2("c")], [lit2("collectionValue", v2("c"))]),
+  rule2(
+    "entryAt",
+    [v2("site"), v2("held")],
+    [
+      lit2("choosesEntry", v2("site"), v2("o")),
+      lit2("containerOf", v2("o"), v2("obj")),
+      lit2("contains", v2("obj"), v2("n"), v2("held"))
+    ],
+    "any entry"
+  ),
+  rule2(
+    "entryAt",
+    [v2("site"), v2("held")],
+    [
+      lit2("namedEntryRead", v2("site"), v2("o"), v2("n")),
+      lit2("containerOf", v2("o"), v2("obj")),
+      lit2("contains", v2("obj"), v2("n"), v2("held"))
+    ],
+    "named entry"
+  ),
+  rule2(
+    "entryAt",
+    [v2("site"), v2("held")],
+    [lit2("computedEntryAt", v2("site"), v2("held"))]
+  ),
+  // A write under a key the source computes, `T[name] = fn` or a map's
+  // `set`, could be under any name, so every read of the container may
+  // come back with it, a read narrowed to one name included.
+  rule2(
+    "computedEntryAt",
+    [v2("site"), v2("held")],
+    [
+      lit2("entryRead", v2("site"), v2("o")),
+      lit2("containerOf", v2("o"), v2("c")),
+      lit2("refersToObject", v2("x"), v2("c")),
+      lit2("holdsUnderKey", v2("x"), v2("held"))
+    ],
+    "entry under a computed key"
+  ),
+  // The read a call takes its function from: the callee itself, a name
+  // for it, or the call when the call is the read, as Ruby's `send` is.
+  rule2(
+    "callsEntryAt",
+    [v2("r"), v2("site")],
+    [lit2("call", v2("r"), v2("site")), lit2("entryRead", v2("site"), v2("o"))]
+  ),
+  rule2(
+    "callsEntryAt",
+    [v2("r"), v2("site")],
+    [
+      lit2("call", v2("r"), v2("c")),
+      lit2("reaches", v2("c"), v2("site"), VALUE_STEP),
+      lit2("entryRead", v2("site"), v2("o"))
+    ]
+  ),
+  rule2("callsEntryAt", [v2("r"), v2("r")], [lit2("callsChosenEntry", v2("r"))]),
+  rule2(
+    "callsEntryAt",
+    [v2("r"), v2("site")],
+    [lit2("callsEntryInBranch", v2("r"), v2("site"))]
+  ),
+  // `c ? T[k] : undefined` is one of its branches, so a call through it
+  // may run what the read gives. The other branch may be some other
+  // function, so dispatch.ts never counts such a call as certain.
+  rule2(
+    "callsEntryInBranch",
+    [v2("r"), v2("site")],
+    [lit2("call", v2("r"), v2("c")), lit2("branchReadsEntry", v2("c"), v2("site"))]
+  ),
+  rule2(
+    "callsEntryInBranch",
+    [v2("r"), v2("site")],
+    [
+      lit2("call", v2("r"), v2("c")),
+      lit2("reaches", v2("c"), v2("x"), VALUE_STEP),
+      lit2("branchReadsEntry", v2("x"), v2("site"))
+    ]
+  ),
+  rule2(
+    "branchReadsEntry",
+    [v2("x"), v2("site")],
+    [
+      lit2("conditionalBranch", v2("x"), v2("site")),
+      lit2("entryRead", v2("site"), v2("o"))
+    ]
+  ),
+  rule2(
+    "branchReadsEntry",
+    [v2("x"), v2("site")],
+    [
+      lit2("conditionalBranch", v2("x"), v2("b")),
+      lit2("reaches", v2("b"), v2("site"), VALUE_STEP),
+      lit2("entryRead", v2("site"), v2("o"))
+    ]
+  ),
+  rule2(
+    "dispatchesTo",
+    [v2("r"), v2("f")],
+    [
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("entryAt", v2("site"), v2("held")),
+      lit2("comesTo", v2("held"), v2("f")),
+      lit2("func", v2("f"))
+    ]
+  ),
+  // A collection a program fills is an object the way a written one is,
+  // so a write through a name for it lands on it.
+  rule2("refersToObject", [v2("c"), v2("c")], [lit2("collectionValue", v2("c"))])
+];
 var STATED_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
   // Every chain that follows a name takes the name hops, so a hop added
@@ -3463,6 +3894,17 @@ var STATED_RULES = [
       lit2("callsNamed", v2("r"), v2("r0"))
     ]
   ),
+  // The same, called straight off the factory's call, as
+  // `register("created")(handler)` or a Python decorator written that way.
+  rule2(
+    "callsFunction",
+    [v2("r"), v2("f")],
+    [
+      lit2("returnsValue", v2("g"), v2("f")),
+      lit2("callsFunction", v2("r0"), v2("g")),
+      lit2("call", v2("r"), v2("r0"))
+    ]
+  ),
   // The expressions that refer to an object under another name, through
   // a name hop or an import. Asked from the object, so it visits only
   // them.
@@ -3908,6 +4350,7 @@ var STATED_RULES = [
     [v2("x"), v2("z")],
     [lit2("comesTo", v2("x"), v2("z")), lit2("func", v2("z"))]
   ),
+  ...DISPATCH_RULES,
   ...PASSED_ON_RULES
 ];
 function alsoSteps(rules) {
@@ -4111,18 +4554,112 @@ var RESOLUTION_QUESTIONS = [
   ),
   // The functions whose return becomes the exit code: a call the value
   // that ends up as the code is, or one it reaches. DESIGN.md has the seeds.
+  rule2("exitStart", [v2("x"), v2("x")], [lit2("wantedExitSink", v2("x"))]),
+  // `reaches` takes no step through a call that picks its function from a
+  // table, so the walk starts again from what each function there returns.
+  rule2(
+    "exitStart",
+    [v2("x"), v2("ret")],
+    [
+      lit2("exitReached", v2("x"), v2("y")),
+      lit2("dispatchesTo", v2("y"), v2("f")),
+      lit2("returnsValue", v2("f"), v2("ret"))
+    ]
+  ),
+  rule2("exitReached", [v2("x"), v2("s")], [lit2("exitStart", v2("x"), v2("s"))]),
+  rule2(
+    "exitReached",
+    [v2("x"), v2("y")],
+    [
+      lit2("exitStart", v2("x"), v2("s")),
+      lit2("reaches", v2("s"), v2("y"), v2("kind"))
+    ]
+  ),
   rule2(
     "wantedExitCodeFrom",
     [v2("x"), v2("f")],
-    [lit2("wantedExitSink", v2("x")), lit2("invokes", v2("x"), v2("f"))]
+    [lit2("exitReached", v2("x"), v2("y")), lit2("invokes", v2("y"), v2("f"))]
   ),
   rule2(
     "wantedExitCodeFrom",
     [v2("x"), v2("f")],
+    [lit2("exitReached", v2("x"), v2("y")), lit2("dispatchesTo", v2("y"), v2("f"))]
+  ),
+  // The functions a call may run when it takes one from a table, with the
+  // entry each came from, and the entries that come to no function. The
+  // reader in dispatch.ts decides whether the call runs exactly one.
+  rule2(
+    "wantedDispatchSite",
+    [v2("r"), v2("site")],
+    [lit2("wantedDispatch", v2("r")), lit2("callsEntryAt", v2("r"), v2("site"))]
+  ),
+  rule2(
+    "wantedDispatchEntry",
+    [v2("r"), v2("held")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("entryAt", v2("site"), v2("held"))
+    ]
+  ),
+  rule2(
+    "wantedDispatchInBranch",
+    [v2("r"), v2("site")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryInBranch", v2("r"), v2("site"))
+    ]
+  ),
+  rule2(
+    "wantedDispatchComputed",
+    [v2("r"), v2("held")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("computedEntryAt", v2("site"), v2("held"))
+    ]
+  ),
+  rule2(
+    "wantedDispatchFunction",
+    [v2("r"), v2("held"), v2("f")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("entryAt", v2("site"), v2("held")),
+      lit2("comesTo", v2("held"), v2("f")),
+      lit2("func", v2("f"))
+    ]
+  ),
+  rule2(
+    "wantedDispatchLikeEntry",
+    [v2("r"), v2("site"), v2("n"), v2("held")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("likeEntryAt", v2("site"), v2("n"), v2("held"))
+    ]
+  ),
+  rule2(
+    "wantedDispatchLikeFunction",
+    [v2("r"), v2("held"), v2("f")],
+    [
+      lit2("wantedDispatch", v2("r")),
+      lit2("callsEntryAt", v2("r"), v2("site")),
+      lit2("likeEntryAt", v2("site"), v2("n"), v2("held")),
+      lit2("comesTo", v2("held"), v2("f")),
+      lit2("func", v2("f"))
+    ]
+  ),
+  // What a function there calls in its own body, for an entry written as
+  // a lambda, which no summary describes.
+  rule2(
+    "wantedDispatchThrough",
+    [v2("r"), v2("f"), v2("g")],
     [
-      lit2("wantedExitSink", v2("x")),
-      lit2("reaches", v2("x"), v2("y"), v2("kind")),
-      lit2("invokes", v2("y"), v2("f"))
+      lit2("wantedDispatch", v2("r")),
+      lit2("dispatchesTo", v2("r"), v2("f")),
+      lit2("makesCall", v2("f"), v2("r2")),
+      lit2("invokes", v2("r2"), v2("g"))
     ]
   ),
   // The calls that hand a stream on, so the asker can read the callee's file.
@@ -4556,6 +5093,7 @@ export {
   ASKING_RELATIONS,
   BASE_CLASS_RULE,
   DEFAULT_IMPORT_NAME,
+  DISPATCH_QUESTION,
   DependencyLedger,
   EntryReuse,
   FACT_CONTRACT_CASES,
@@ -4573,14 +5111,18 @@ export {
   RESOLUTION_QUESTIONS,
   RESOLUTION_RULES,
   RESULT_STEP,
+  SPREAD_ENTRY,
   UNDER_ANSWER_RELATIONS,
   UNDER_QUESTION_ROW_BUDGET,
   UNDER_RUN_ROW_BUDGET,
   UNPLACED_STORE_NAME,
   USES_QUESTION,
+  VALUE_ENTRY,
   VALUE_STEP,
   WatchedMap,
+  addEntryRows,
   addPackWords,
+  addTemplateRows,
   agreedMountPrefix,
   allocationSitesOf,
   alsoSteps,
@@ -4597,6 +5139,7 @@ export {
   comesToUnder,
   couldBeSettled,
   declaredTypesOf,
+  dispatchOutcomes,
   exitCodeFunctions,
   explainResolutionProof,
   explainResolvedKey,
@@ -4618,6 +5161,7 @@ export {
   packHashes,
   proofRules,
   queryFacts,
+  readDispatchOutcomes,
   readUses,
   recordsToReplay,
   renderExplanation,
@@ -4626,6 +5170,7 @@ export {
   resolvedFunctions,
   settledFunction,
   sourceLeavesOf,
+  spanOfKey,
   startsAtName,
   staysInItsFunction,
   stillValid,