@suss/resolution 0.30.0 → 0.31.1

package/dist/index.js

@@ -1,7 +1,18 @@
 // src/program.ts
-import { clearRelations, deriveOnDemand, evaluate } from "@suss/datalog";
+import {
+  BudgetExhausted,
+  chargeAbandoned,
+  chargeQuestion,
+  clearRelations,
+  deriveOnDemand,
+  evaluate,
+  rowBudget,
+  tupleKey
+} from "@suss/datalog";
 var ASKING_RELATIONS = [
   "wanted",
+  "wantedUnder",
+  "wantedSites",
   "wantedOrigin",
   "wantedCallOrigin",
   "wantedExportsOf",
@@ -11,8 +22,12 @@ var ASKING_RELATIONS = [
 ];
 var NO_LANGUAGE_RULES = [];
 var programs = /* @__PURE__ */ new WeakMap();
-function resolutionProgram(languageRules = NO_LANGUAGE_RULES) {
-  const built = programs.get(languageRules);
+var underPrograms = /* @__PURE__ */ new WeakMap();
+var contextFreeAnswers = () => ANSWER_RELATIONS.filter(
+  (relation) => !UNDER_ANSWER_RELATIONS.includes(relation)
+);
+function builtProgram(languageRules, cache, complete) {
+  const built = cache.get(languageRules);
   if (built !== void 0) {
     return built;
   }
@@ -21,10 +36,16 @@ function resolutionProgram(languageRules = NO_LANGUAGE_RULES) {
     ...languageRules,
     ...RESOLUTION_QUESTIONS
   ];
-  const program = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? { rules, demandDriven: [], demands: [] } : deriveOnDemand(rules, ANSWER_RELATIONS);
-  programs.set(languageRules, program);
+  const program = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? { rules, demandDriven: [], demands: [] } : deriveOnDemand(rules, complete);
+  cache.set(languageRules, program);
   return program;
 }
+function resolutionProgram(languageRules = NO_LANGUAGE_RULES) {
+  return builtProgram(languageRules, programs, contextFreeAnswers());
+}
+function resolutionUnderProgram(languageRules = NO_LANGUAGE_RULES) {
+  return builtProgram(languageRules, underPrograms, ANSWER_RELATIONS);
+}
 function queryFacts(program) {
   if (program.demandDriven.length === 0) {
     return [];
@@ -61,6 +82,75 @@ function askResolution(db, keys, asking = "wanted", program = resolutionProgram(
     clearRelations(db, program.rules, forget);
   }
 }
+var askedUnderByDb = /* @__PURE__ */ new WeakMap();
+var UNDER_QUESTION_ROW_BUDGET = 2e7;
+var UNDER_RUN_ROW_BUDGET = 4e7;
+var spentUnderByDb = /* @__PURE__ */ new WeakMap();
+function spendOf(db) {
+  let spend = spentUnderByDb.get(db);
+  if (spend === void 0) {
+    spend = { rows: 0, asked: 0, abandoned: 0, skipped: 0 };
+    spentUnderByDb.set(db, spend);
+  }
+  return spend;
+}
+function underQuestionSpend(db) {
+  return { ...spendOf(db) };
+}
+function askResolutionUnder(db, pairs, program = resolutionUnderProgram(), questionBudget = UNDER_QUESTION_ROW_BUDGET, runBudget = UNDER_RUN_ROW_BUDGET) {
+  let asked = askedUnderByDb.get(db);
+  if (asked === void 0) {
+    asked = /* @__PURE__ */ new Set();
+    askedUnderByDb.set(db, asked);
+  }
+  const fresh = [...pairs].filter(
+    ([key, site]) => !asked.has(tupleKey([key, site]))
+  );
+  if (fresh.length === 0) {
+    return "answered";
+  }
+  const spend = spendOf(db);
+  for (const [key, site] of fresh) {
+    asked.add(tupleKey([key, site]));
+  }
+  spend.asked += 1;
+  if (spend.rows >= runBudget) {
+    spend.skipped += 1;
+    chargeQuestion("skipped");
+    return "abandoned";
+  }
+  for (const [key, site] of fresh) {
+    db.add("wantedUnder", [key, site]);
+  }
+  const forget = queryFacts(program);
+  const clearDerived = () => {
+    if (forget.length > 0) {
+      clearRelations(db, program.rules, forget);
+    }
+  };
+  const budget = rowBudget(questionBudget);
+  try {
+    evaluate(db, program.rules, void 0, budget);
+  } catch (error) {
+    if (!(error instanceof BudgetExhausted)) {
+      throw error;
+    }
+    spend.rows += error.examined;
+    spend.abandoned += 1;
+    chargeQuestion("abandoned");
+    db.retract("wantedUnder", fresh);
+    clearDerived();
+    chargeAbandoned(
+      fresh.map(([key, site]) => `${key} under ${site}`).join(", "),
+      error.examined
+    );
+    return "abandoned";
+  }
+  spend.rows += budget.examined;
+  chargeQuestion();
+  clearDerived();
+  return "answered";
+}
 
 // src/callee.ts
 var UNDECLARED = { kind: "undeclared" };
@@ -489,6 +579,12 @@ var DEFAULT_PHRASES = {
   "last write": ({ tuple, describe }) => ({
     reason: `${describe(tuple[0])} is written more than once, and the last write leaves it as ${describe(tuple[1])}`
   }),
+  "one of several writes": ({ tuple, describe }) => ({
+    reason: `${describe(tuple[0])} is written more than once, and one of those writes makes it ${describe(tuple[1])}`,
+    assumptions: [
+      `nothing says which write to ${describe(tuple[0])} ran last, so every write it has is a possible value`
+    ]
+  }),
   fallback: ({ tuple, describe }) => ({
     reason: `${describe(tuple[0])} is a fallback expression, and ${describe(tuple[1])} is the branch that resolves`
   }),
@@ -505,7 +601,7 @@ var DEFAULT_PHRASES = {
   "property read": ({ tuple, premises, describe }) => {
     const [, object, name] = premises[0].tuple;
     const contains = premises[2];
-    const inherited = contains.kind === "derived" && contains.premises.length > 1;
+    const inherited = contains.kind === "derived" && ruleLabel(contains.rule) === BASE_CLASS_RULE;
     return {
       reason: `${describe(tuple[0])} reads ${String(name)} off ${describe(object)}, which contains ${describe(tuple[1])}`,
       notes: inherited ? [`${String(name)} comes from a base class`] : []
@@ -584,7 +680,8 @@ var CHAIN_RELATIONS = /* @__PURE__ */ new Set([
   "isWrittenAs",
   "comesFrom",
   "reaches",
-  "stepsTo"
+  "stepsTo",
+  "hop"
 ]);
 function inlineChain(proof, state) {
   const explained = explainResolutionProof(proof, {
@@ -640,6 +737,17 @@ function importStep(proof, state) {
     assumptions: []
   };
 }
+function namespaceMemberStep(proof, state) {
+  const [x, module, name] = proof.tuple;
+  return {
+    from: x,
+    to: module,
+    rule: NAMESPACE_MEMBER_RULE,
+    reason: `${state.describe(x)} reads ${String(name)} off ${state.describe(module)}, which is imported whole`,
+    notes: [],
+    assumptions: []
+  };
+}
 var flattenInto = (proof, state) => {
   if (proof.kind === "truncated") {
     state.truncated = true;
@@ -649,7 +757,7 @@ var flattenInto = (proof, state) => {
     return;
   }
   const relation = proof.relation;
-  if (relation === "stepsTo") {
+  if (relation === "stepsTo" || relation === "hop") {
     state.steps.push(stepFrom(proof, state));
     return;
   }
@@ -660,6 +768,10 @@ var flattenInto = (proof, state) => {
     return;
   }
   if (relation === "comesFrom") {
+    if (ruleLabel(proof.rule) === NAMESPACE_MEMBER_RULE) {
+      state.steps.push(namespaceMemberStep(proof, state));
+      return;
+    }
     if (proof.premises.length === 2) {
       flattenInto(proof.premises[0], state);
       state.steps.push(importStep(proof.premises[1], state));
@@ -836,6 +948,37 @@ function nodeOfKey(rootsByFile, key) {
   return null;
 }
 
+// src/packWords.ts
+function addPackWords(db, words) {
+  for (const word of words.givesBackOne ?? []) {
+    db.add("givesBackOne", [word.base, word.method]);
+  }
+  for (const word of words.givesBackOneOfArgument ?? []) {
+    db.add("givesBackOneOfArgument", [
+      word.base,
+      word.method,
+      String(word.argument)
+    ]);
+  }
+  for (const word of words.givesBackOneOfImport ?? []) {
+    db.add("givesBackOneOfImport", [
+      word.module,
+      word.name,
+      String(word.argument)
+    ]);
+  }
+  for (const word of words.entersAsSelf ?? []) {
+    db.add("entersAsSelf", [word.module, word.name]);
+  }
+  for (const word of words.unwrapsByName ?? []) {
+    db.add("unwrapsByName", [word.callee, String(word.argument)]);
+    db.add("wrapperModule", [word.callee, word.module]);
+  }
+  for (const word of words.associationConstructor ?? []) {
+    db.add("associationConstructor", [word.module, word.name]);
+  }
+}
+
 // src/session.ts
 import { Database, evaluate as evaluate2, proofOf, witnesses } from "@suss/datalog";
 function explainResolvedKey(options) {
@@ -891,7 +1034,7 @@ function explainResolvedKey(options) {
 
 // src/singleAnswer.ts
 var NO_PLACEHOLDERS = /* @__PURE__ */ new Set();
-function singleAnswers(rows, placeholders = NO_PLACEHOLDERS) {
+function answersByKey(rows, placeholders = NO_PLACEHOLDERS) {
   const candidates = /* @__PURE__ */ new Map();
   for (const row of rows) {
     const key = String(row[0]);
@@ -903,9 +1046,15 @@ function singleAnswers(rows, placeholders = NO_PLACEHOLDERS) {
     set.add(answer);
     candidates.set(key, set);
   }
-  const settled = /* @__PURE__ */ new Map();
+  const answers = /* @__PURE__ */ new Map();
   for (const [key, set] of candidates) {
-    const answers = withoutPlaceholders(set, placeholders);
+    answers.set(key, withoutPlaceholders(set, placeholders));
+  }
+  return answers;
+}
+function singleAnswers(rows, placeholders = NO_PLACEHOLDERS) {
+  const settled = /* @__PURE__ */ new Map();
+  for (const [key, answers] of answersByKey(rows, placeholders)) {
     if (answers.length === 1) {
       settled.set(key, answers[0]);
     }
@@ -923,6 +1072,28 @@ function withoutPlaceholders(answers, placeholders) {
   return kept;
 }
 
+// src/underContext.ts
+function answersUnder(db, relation, key, site) {
+  return db.lookup(relation, 0, key).filter((row) => String(row[1]) === site).map((row) => String(row[2]));
+}
+function isWrittenAsUnder(db, key, site) {
+  return answersUnder(db, "wantedIsWrittenAsUnder", key, site);
+}
+function comesToUnder(db, key, site) {
+  return answersUnder(db, "wantedComesToUnder", key, site);
+}
+function objectOfUnder(db, key, site) {
+  return answersUnder(db, "wantedObjectOfUnder", key, site);
+}
+function writtenValueUnder(db, key, site) {
+  const rows = isWrittenAsUnder(db, key, site).map((answer) => [key, answer]);
+  const answers = answersByKey(rows, placeholderValues(db)).get(key) ?? [];
+  return answers.length === 1 ? answers[0] : null;
+}
+function allocationSitesOf(db, cls) {
+  return db.lookup("wantedAllocatedAt", 0, cls).map((row) => String(row[1]));
+}
+
 // src/writes.ts
 function valueLeftByWrites(writes, ordered) {
   const deciding = writes.filter((write) => !write.narrowsName);
@@ -953,23 +1124,58 @@ function sharedConstruction(writes) {
 }
 
 // src/writtenValue.ts
-function writtenValueOf(db, key, ask) {
-  const placeholders = placeholderValues(db);
-  const direct = singleAnswers(db.facts("wantedIsWrittenAs"), placeholders).get(
-    key
-  );
-  if (direct === void 0) {
-    return null;
+var WRITTEN_AS = "wantedIsWrittenAs";
+function writtenValueOf(db, key, ask, relation = WRITTEN_AS) {
+  const answers = settledByKey(db, [key], ask, relation).get(key) ?? [];
+  return answers.length === 1 ? answers[0] : null;
+}
+function writtenValuesOf(db, key, ask, relation = WRITTEN_AS) {
+  const settled = settledByKey(db, [key], ask, relation).get(key) ?? [];
+  return settled.length > 0 ? settled : writesLeft(db, key);
+}
+function writtenValuesByKey(db, keys, ask, relation = WRITTEN_AS) {
+  const one = /* @__PURE__ */ new Map();
+  for (const [key, answers] of settledByKey(db, keys, ask, relation)) {
+    if (answers.length === 1) {
+      one.set(key, answers[0]);
+    }
   }
-  const isCall = db.facts("call").some((row) => String(row[0]) === direct);
-  if (!isCall) {
+  return one;
+}
+function settledByKey(db, keys, ask, relation) {
+  const placeholders = placeholderValues(db);
+  const byKey = answersByKey(db.facts(relation), placeholders);
+  const direct = new Map(keys.map((key) => [key, byKey.get(key) ?? []]));
+  const calls = new Set(db.facts("call").map((row) => String(row[0])));
+  const throughCalls = [...direct.values()].flat().filter((answer) => calls.has(answer));
+  if (throughCalls.length === 0) {
     return direct;
   }
-  ask([direct]);
-  const deeper = singleAnswers(db.facts("wantedIsWrittenAs"), placeholders).get(
-    direct
+  ask(throughCalls);
+  const deeper = singleAnswers(db.facts(relation), placeholders);
+  return new Map(
+    [...direct].map(([key, answers]) => [
+      key,
+      collapseCalls(answers, calls, deeper)
+    ])
   );
-  return deeper ?? direct;
+}
+function collapseCalls(direct, calls, deeper) {
+  return [
+    ...new Set(
+      direct.map(
+        (answer) => calls.has(answer) ? deeper.get(answer) ?? answer : answer
+      )
+    )
+  ];
+}
+function writesLeft(db, key) {
+  const unstated = db.facts("writesUnstated").some((row) => String(row[0]) === key);
+  if (unstated) {
+    return [];
+  }
+  const candidates = answersByKey(db.facts("mayHold"), placeholderValues(db)).get(key) ?? [];
+  return candidates.length > 1 ? candidates : [];
 }
 
 // src/index.ts
@@ -977,38 +1183,61 @@ import { constant, lit, rule, variable as v } from "@suss/datalog";
 var VALUE_STEP = constant("value");
 var NAMESPACE_IMPORT_NAME = "*";
 var NAMESPACE_IMPORT = constant(NAMESPACE_IMPORT_NAME);
+var NAMESPACE_MEMBER_RULE = "namespace member";
+var BASE_CLASS_RULE = "base class";
+var INSTANCE_STEP = constant("instance");
 var RESULT_STEP = constant("result");
-var RESOLUTION_RULES = [
+var NO_CONTEXT_NAME = "none";
+var NO_CONTEXT = constant(NO_CONTEXT_NAME);
+var STEP_LATTICE = [
+  { soFar: VALUE_STEP, next: v("kind"), took: v("kind") },
+  { soFar: INSTANCE_STEP, next: VALUE_STEP, took: INSTANCE_STEP },
+  { soFar: INSTANCE_STEP, next: INSTANCE_STEP, took: INSTANCE_STEP },
+  { soFar: INSTANCE_STEP, next: RESULT_STEP, took: RESULT_STEP },
+  { soFar: RESULT_STEP, next: VALUE_STEP, took: RESULT_STEP },
+  { soFar: RESULT_STEP, next: INSTANCE_STEP, took: RESULT_STEP },
+  { soFar: RESULT_STEP, next: RESULT_STEP, took: RESULT_STEP }
+];
+var STATED_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
   // A language with a hop of its own, like JavaScript's `.bind`, states
   // it as a step too, or every question but `comesTo` misses it.
   rule(
-    "stepsTo",
+    "hop",
     [v("x"), v("y"), VALUE_STEP],
     [lit("binds", v("x"), v("y"))],
     "alias"
   ),
   // A name written more than once has the value the last write left
-  // there. The adapter works out which write that is and stays quiet
-  // when control flow decides, so such a name steps nowhere at all.
+  // there. The adapter works out which write that is, and stays quiet
+  // when control flow decides; the rule below takes that name instead.
   rule(
-    "stepsTo",
+    "hop",
     [v("x"), v("y"), VALUE_STEP],
     [lit("endsHolding", v("x"), v("y"))],
     "last write"
   ),
+  // A name whose writes nothing orders leads to each of them, so a
+  // caller that can use several values gets them all and one that needs
+  // a single value gets none. A write stating no value stops every step.
+  rule(
+    "hop",
+    [v("x"), v("y"), VALUE_STEP],
+    [lit("mayHold", v("x"), v("y")), lit("writesAllStated", v("x"))],
+    "one of several writes"
+  ),
   // A fallback says the value is one of its branches, so each branch is
   // a step. A branch that resolves to nothing makes no claim, and two
   // branches resolving to different things fail the single-answer policy.
   rule(
-    "stepsTo",
+    "hop",
     [v("x"), v("b"), VALUE_STEP],
     [lit("fallbackBranch", v("x"), v("b"))],
     "fallback"
   ),
   // An import steps to what the module exports under that name.
   rule(
-    "stepsTo",
+    "hop",
     [v("x"), v("value"), VALUE_STEP],
     [
       lit("imports", v("x"), v("m"), v("n")),
@@ -1042,8 +1271,8 @@ var RESOLUTION_RULES = [
   // a method read off the result is the one the class declares. The
   // caveat below is about a factory function, and a class is not one.
   rule(
-    "stepsTo",
-    [v("r"), v("cls"), VALUE_STEP],
+    "hop",
+    [v("r"), v("cls"), INSTANCE_STEP],
     [
       lit("call", v("r"), v("c")),
       lit("comesTo", v("c"), v("cls")),
@@ -1051,12 +1280,21 @@ var RESOLUTION_RULES = [
     ],
     "class instance"
   ),
+  // The receiver a method is called on. Being one of a class is the
+  // same hop a construction takes, so a method read off `self` finds
+  // what the class declares.
+  rule(
+    "hop",
+    [v("x"), v("cls"), INSTANCE_STEP],
+    [lit("instanceOf", v("x"), v("cls"))],
+    "receiver instance"
+  ),
   // A finder the library declares, keyed on the base a pack named so a
   // project class with a method of the same name on another hierarchy is
   // left alone. The DESIGN says what a chain of them composes into.
   rule(
-    "stepsTo",
-    [v("r"), v("cls"), VALUE_STEP],
+    "hop",
+    [v("r"), v("cls"), INSTANCE_STEP],
     [
       lit("call", v("r"), v("c")),
       lit("readsProperty", v("c"), v("o"), v("m")),
@@ -1073,8 +1311,8 @@ var RESOLUTION_RULES = [
   // instead of as the receiver. The argument having to reach the base a
   // pack named is what keeps an unrelated `get` out.
   rule(
-    "stepsTo",
-    [v("r"), v("cls"), VALUE_STEP],
+    "hop",
+    [v("r"), v("cls"), INSTANCE_STEP],
     [
       lit("call", v("r"), v("c")),
       lit("readsProperty", v("c"), v("o"), v("m")),
@@ -1091,8 +1329,8 @@ var RESOLUTION_RULES = [
   // anything, keyed on the module it was imported from so a project
   // function spelled the same way is not mistaken for it.
   rule(
-    "stepsTo",
-    [v("r"), v("cls"), VALUE_STEP],
+    "hop",
+    [v("r"), v("cls"), INSTANCE_STEP],
     [
       lit("call", v("r"), v("c")),
       lit("comesFrom", v("c"), v("mod"), v("n")),
@@ -1102,10 +1340,24 @@ var RESOLUTION_RULES = [
     ],
     "declared import finder"
   ),
+  // A block opened over a library's own constructor. The pack says
+  // entering one gives back the object it built, so the name the block
+  // opens is that call.
+  rule(
+    "hop",
+    [v("y"), v("r"), VALUE_STEP],
+    [
+      lit("entersAs", v("y"), v("r")),
+      lit("call", v("r"), v("c")),
+      lit("comesFrom", v("c"), v("mod"), v("n")),
+      lit("entersAsSelf", v("mod"), v("n"))
+    ],
+    "context manager returns self"
+  ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
   rule(
-    "stepsTo",
+    "hop",
     [v("r"), v("a"), VALUE_STEP],
     [
       lit("call", v("r"), v("c")),
@@ -1119,7 +1371,7 @@ var RESOLUTION_RULES = [
   // argument k. The callee has to come from the library the pack said,
   // so a local object spelled the same way is not mistaken for it.
   rule(
-    "stepsTo",
+    "hop",
     [v("r"), v("a"), VALUE_STEP],
     [
       lit("calleeName", v("r"), v("n")),
@@ -1133,44 +1385,441 @@ var RESOLUTION_RULES = [
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
   rule(
-    "stepsTo",
+    "hop",
     [v("r"), v("ret"), RESULT_STEP],
     [lit("invokes", v("r"), v("f")), lit("returnsValue", v("f"), v("ret"))],
     "call result"
   ),
-  // Where a walk gets to, and whether it ran a call on the way. The walk
-  // so far comes first, so demand stays on the value asked about; the
-  // README says what the other order cost.
+  // What a function says it gives back when its body never states a
+  // value. The adapter stays quiet about the annotation whenever the
+  // body does state one, so the two never answer the same question.
+  rule(
+    "hop",
+    [v("r"), v("cls"), RESULT_STEP],
+    [
+      lit("invokes", v("r"), v("f")),
+      lit("returnsClass", v("f"), v("x")),
+      lit("comesTo", v("x"), v("cls")),
+      lit("objectValue", v("cls"))
+    ],
+    "declared return type"
+  ),
+  // Where a walk gets to, under the strongest step it took: value, then
+  // instance, then result. The walk so far comes first, so demand stays
+  // on the value asked about; the README says what the other order cost.
   rule(
     "reaches",
     [v("x"), v("z"), v("kind")],
     [lit("stepsTo", v("x"), v("z"), v("kind"))]
   ),
+  // A rule per pair rather than one leaving the next step's kind free. A
+  // free kind is a second question about the same relation, and a
+  // demand-driven run then derives both to answer either.
+  ...STEP_LATTICE.map(
+    ({ soFar, next, took }) => rule(
+      "reaches",
+      [v("x"), v("z"), took],
+      [
+        lit("reaches", v("x"), v("y"), soFar),
+        lit("stepsTo", v("y"), v("z"), next)
+      ]
+    )
+  ),
+  // A context is an allocation site, or nothing at all for a value read
+  // outside every site. Both are stated, so a rule that starts a walk
+  // binds its context from a premise rather than from a negation.
+  rule("context", [NO_CONTEXT], [], "no context"),
+  rule(
+    "context",
+    [v("site")],
+    [lit("allocates", v("site"), v("cls"))],
+    "site context"
+  ),
+  // The same closure, with the context the walk started under and the
+  // context it arrived under. It takes `hop`, because an argument and a
+  // property read have their own rules below.
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("z"), v("c"), v("kind")],
+    [lit("context", v("c")), lit("hop", v("x"), v("z"), v("kind"))],
+    "under one hop"
+  ),
+  ...STEP_LATTICE.map(
+    ({ soFar, next, took }) => rule(
+      "reachesUnder",
+      [v("x"), v("c"), v("z"), v("c2"), took],
+      [
+        lit("reachesUnder", v("x"), v("c"), v("y"), v("c2"), soFar),
+        lit("hop", v("y"), v("z"), next)
+      ]
+    )
+  ),
+  // The receiver read under a site is that site. The ordinary hop from a
+  // receiver to its class stays in `hop`, so `self` under any context
+  // still comes to the class a single-answer reader wants.
   rule(
-    "reaches",
-    [v("x"), v("z"), v("kind")],
+    "reachesUnder",
+    [v("x"), v("c"), v("c"), v("c"), VALUE_STEP],
+    [lit("instanceOf", v("x"), v("cls")), lit("allocates", v("c"), v("cls"))],
+    "receiver is the site"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("c2"), v("c2"), v("kind")],
     [
-      lit("reaches", v("x"), v("y"), VALUE_STEP),
-      lit("stepsTo", v("y"), v("z"), v("kind"))
+      lit("reachesUnder", v("x"), v("c"), v("y"), v("c2"), v("kind")),
+      lit("instanceOf", v("y"), v("cls")),
+      lit("allocates", v("c2"), v("cls"))
+    ],
+    "reached receiver is the site"
+  ),
+  // The object an expression refers to under a context. A site is an
+  // answer here, unlike `objectOf`, and the class an instance is one of
+  // is an answer only under no context.
+  rule(
+    "objectOfUnder",
+    [v("site"), v("c"), v("site")],
+    [lit("context", v("c")), lit("allocates", v("site"), v("cls"))],
+    "site is its own object"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), v("c"), v("site")],
+    [
+      lit("reachesUnder", v("o"), v("c"), v("site"), v("c2"), VALUE_STEP),
+      lit("allocates", v("site"), v("cls"))
+    ],
+    "name of a site"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), v("c"), v("obj")],
+    [
+      lit("reachesUnder", v("o"), v("c"), v("obj"), v("c2"), VALUE_STEP),
+      lit("objectValue", v("obj"))
+    ],
+    "written object under a context"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), v("c"), v("obj")],
+    [
+      lit("reachesUnder", v("o"), v("c"), v("obj"), v("c2"), RESULT_STEP),
+      lit("objectValue", v("obj"))
+    ],
+    "returned object under a context"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), NO_CONTEXT, v("cls")],
+    [
+      lit(
+        "reachesUnder",
+        v("o"),
+        NO_CONTEXT,
+        v("cls"),
+        NO_CONTEXT,
+        INSTANCE_STEP
+      ),
+      lit("objectValue", v("cls"))
+    ],
+    "class reached with no context"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), NO_CONTEXT, v("cls")],
+    [lit("instanceOf", v("o"), v("cls"))],
+    "receiver class with no context"
+  ),
+  rule(
+    "objectOfUnder",
+    [v("o"), v("c"), v("o")],
+    [lit("context", v("c")), lit("objectValue", v("o"))],
+    "object under a context is itself"
+  ),
+  // A property read goes on under the site the object was made at, so a
+  // field read off two constructions gives each one its own value. A
+  // class or a literal object keeps the context the walk was already in.
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("held"), v("site"), VALUE_STEP],
+    [
+      lit("context", v("c")),
+      lit("readsProperty", v("x"), v("o"), v("n")),
+      lit("objectOfUnder", v("o"), v("c"), v("site")),
+      lit("allocates", v("site"), v("cls")),
+      lit("contains", v("site"), v("n"), v("held"))
+    ],
+    "property read at a site"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("held"), v("c"), VALUE_STEP],
+    [
+      lit("context", v("c")),
+      lit("readsProperty", v("x"), v("o"), v("n")),
+      lit("objectOfUnder", v("o"), v("c"), v("obj")),
+      lit("objectValue", v("obj")),
+      lit("contains", v("obj"), v("n"), v("held"))
+    ],
+    "property read off an object"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("held"), v("site"), v("kind")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("y"), v("c2"), v("kind")),
+      lit("readsProperty", v("y"), v("o"), v("n")),
+      lit("objectOfUnder", v("o"), v("c2"), v("site")),
+      lit("allocates", v("site"), v("cls")),
+      lit("contains", v("site"), v("n"), v("held"))
+    ],
+    "reached property read at a site"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("held"), v("c2"), v("kind")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("y"), v("c2"), v("kind")),
+      lit("readsProperty", v("y"), v("o"), v("n")),
+      lit("objectOfUnder", v("o"), v("c2"), v("obj")),
+      lit("objectValue", v("obj")),
+      lit("contains", v("obj"), v("n"), v("held"))
+    ],
+    "reached property read off an object"
+  ),
+  // A parameter goes on at the argument, under the context its caller
+  // was read in, and only from the calls that run the function under the
+  // context the walk is in. This is the one hop that changes context.
+  rule(
+    "reachesUnder",
+    [v("p"), v("c"), v("a"), v("c3"), VALUE_STEP],
+    [
+      lit("context", v("c")),
+      lit("paramOf", v("f"), v("i"), v("p")),
+      lit("entersUnder", v("r"), v("f"), v("c"), v("c3")),
+      lit("callArg", v("r"), v("i"), v("a"))
+    ],
+    "argument under a context"
+  ),
+  rule(
+    "reachesUnder",
+    [v("p"), v("c"), v("a"), v("c3"), VALUE_STEP],
+    [
+      lit("context", v("c")),
+      lit("paramNamed", v("f"), v("n"), v("p")),
+      lit("entersUnder", v("r"), v("f"), v("c"), v("c3")),
+      lit("callKeywordArg", v("r"), v("n"), v("a"))
+    ],
+    "keyword argument under a context"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("a"), v("c3"), v("kind")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("p"), v("c2"), v("kind")),
+      lit("paramOf", v("f"), v("i"), v("p")),
+      lit("entersUnder", v("r"), v("f"), v("c2"), v("c3")),
+      lit("callArg", v("r"), v("i"), v("a"))
+    ],
+    "reached argument under a context"
+  ),
+  rule(
+    "reachesUnder",
+    [v("x"), v("c"), v("a"), v("c3"), v("kind")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("p"), v("c2"), v("kind")),
+      lit("paramNamed", v("f"), v("n"), v("p")),
+      lit("entersUnder", v("r"), v("f"), v("c2"), v("c3")),
+      lit("callKeywordArg", v("r"), v("n"), v("a"))
+    ],
+    "reached keyword argument under a context"
+  ),
+  // Which call runs which function under which context. A construction
+  // runs its constructor under the site it makes, a method call runs
+  // under the site its receiver is, and anything else under no context.
+  rule(
+    "entersUnder",
+    [v("site"), v("ctor"), v("site"), v("caller")],
+    [
+      lit("allocates", v("site"), v("cls")),
+      lit("runsConstructor", v("cls"), v("ctor")),
+      lit("callUnder", v("site"), v("caller"))
+    ],
+    "construction enters its constructor"
+  ),
+  rule(
+    "entersUnder",
+    [v("r"), v("f"), v("site"), v("caller")],
+    [
+      lit("call", v("r"), v("cal")),
+      lit("readsProperty", v("cal"), v("o"), v("m")),
+      lit("objectOfUnder", v("o"), v("caller"), v("site")),
+      lit("allocates", v("site"), v("cls")),
+      lit("contains", v("site"), v("m"), v("f")),
+      lit("callUnder", v("r"), v("caller"))
+    ],
+    "method call enters under its receiver"
+  ),
+  // A call written as a name runs with whatever receiver the body
+  // around it has, so a plain function called from a method keeps the
+  // site rather than taking every caller of it.
+  rule(
+    "entersUnder",
+    [v("r"), v("f"), v("c"), v("c")],
+    [
+      lit("context", v("c")),
+      lit("callsNamed", v("r"), v("f")),
+      lit("callUnder", v("r"), v("c"))
+    ],
+    "named call enters under the site it is made in"
+  ),
+  rule(
+    "entersUnder",
+    [v("r"), v("f"), NO_CONTEXT, v("caller")],
+    [
+      lit("callsFunction", v("r"), v("f")),
+      lit("callUnder", v("r"), v("caller"))
+    ],
+    "call enters with no context"
+  ),
+  // The constructor a construction runs, the ancestry included, so a
+  // subclass that declares none still fills in what it inherits.
+  rule(
+    "runsConstructor",
+    [v("cls"), v("f")],
+    [lit("initializes", v("cls"), v("f"))]
+  ),
+  rule(
+    "runsConstructor",
+    [v("cls"), v("f")],
+    [
+      lit("extends", v("cls"), v("b")),
+      lit("comesTo", v("b"), v("base")),
+      lit("runsConstructor", v("base"), v("f"))
     ]
   ),
-  // Two rules rather than one leaving the next step's kind free. A free
-  // kind is a second question about the same relation, and a
-  // demand-driven run then derives both to answer either.
+  // Which body a call is written in. One adapter states the call it
+  // found and another states the callee, so both spellings are read.
   rule(
-    "reaches",
-    [v("x"), v("z"), RESULT_STEP],
+    "callInBody",
+    [v("f"), v("r")],
+    [lit("bodyCallsDeep", v("f"), v("r")), lit("call", v("r"), v("c"))]
+  ),
+  rule(
+    "callInBody",
+    [v("f"), v("r")],
+    [lit("bodyCallsDeep", v("f"), v("c")), lit("call", v("r"), v("c"))]
+  ),
+  // The context a call is made under: every site of the class whose
+  // method or constructor it is written in, and no context for a call
+  // outside every method body.
+  rule(
+    "callUnder",
+    [v("r"), v("site")],
+    [
+      lit("callInBody", v("f"), v("r")),
+      lit("holdsProperty", v("cls"), v("m"), v("f")),
+      lit("allocates", v("site"), v("cls"))
+    ],
+    "call in a method"
+  ),
+  rule(
+    "callUnder",
+    [v("r"), v("site")],
     [
-      lit("reaches", v("x"), v("y"), RESULT_STEP),
-      lit("stepsTo", v("y"), v("z"), VALUE_STEP)
+      lit("callInBody", v("f"), v("r")),
+      lit("initializes", v("cls"), v("f")),
+      lit("allocates", v("site"), v("cls"))
+    ],
+    "call in a constructor"
+  ),
+  // A plain function entered under a site makes its own calls under
+  // that site, so a chain of plain functions off one method keeps it.
+  rule(
+    "callUnder",
+    [v("r"), v("c")],
+    [
+      lit("callOutsideMethod", v("r")),
+      lit("callInBody", v("f"), v("r")),
+      lit("entersUnder", v("into"), v("f"), v("c"), v("c4"))
+    ],
+    "call in a function entered under a site"
+  ),
+  rule(
+    "callUnder",
+    [v("r"), NO_CONTEXT],
+    [lit("callOutsideMethod", v("r"))],
+    "call outside every method"
+  ),
+  // The two questions a caller puts under a context, stopping where
+  // `isWrittenAs` and `comesTo` stop, whatever context the walk ended in.
+  rule(
+    "isWrittenAsUnder",
+    [v("x"), v("c"), v("x")],
+    [lit("context", v("c")), lit("writtenValue", v("x"))]
+  ),
+  rule(
+    "isWrittenAsUnder",
+    [v("x"), v("c"), v("x")],
+    [lit("context", v("c")), lit("objectValue", v("x"))]
+  ),
+  rule(
+    "isWrittenAsUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), VALUE_STEP),
+      lit("writtenValue", v("z"))
     ]
   ),
   rule(
-    "reaches",
-    [v("x"), v("z"), RESULT_STEP],
+    "isWrittenAsUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), VALUE_STEP),
+      lit("objectValue", v("z"))
+    ]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("x")],
+    [lit("context", v("c")), lit("func", v("x"))]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("x")],
+    [lit("context", v("c")), lit("objectValue", v("x"))]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), VALUE_STEP),
+      lit("func", v("z"))
+    ]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), VALUE_STEP),
+      lit("objectValue", v("z"))
+    ]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), INSTANCE_STEP),
+      lit("func", v("z"))
+    ]
+  ),
+  rule(
+    "comesToUnder",
+    [v("x"), v("c"), v("z")],
     [
-      lit("reaches", v("x"), v("y"), RESULT_STEP),
-      lit("stepsTo", v("y"), v("z"), RESULT_STEP)
+      lit("reachesUnder", v("x"), v("c"), v("z"), v("c2"), INSTANCE_STEP),
+      lit("objectValue", v("z"))
     ]
   ),
   // What a value comes down to: the walk that never ran a call, stopped
@@ -1188,6 +1837,18 @@ var RESOLUTION_RULES = [
     [v("x"), v("z")],
     [lit("reaches", v("x"), v("z"), VALUE_STEP), lit("objectValue", v("z"))]
   ),
+  // An instance walk stops the same way, so a method read off
+  // `new App()` still finds what the class declares.
+  rule(
+    "comesTo",
+    [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), INSTANCE_STEP), lit("func", v("z"))]
+  ),
+  rule(
+    "comesTo",
+    [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), INSTANCE_STEP), lit("objectValue", v("z"))]
+  ),
   // The same stopping condition, for the walk that ran a call. A call
   // gets no `comesTo` answer on purpose: coming back with what a
   // factory returned would fight the unwrapping answer.
@@ -1228,6 +1889,13 @@ var RESOLUTION_RULES = [
       lit("isWrittenAs", v("ret"), v("z"))
     ]
   ),
+  // Which expression running f hands back, whether f returns it, writes
+  // it into a name first, or ends on it as a shorthand body.
+  rule(
+    "returnsCall",
+    [v("f"), v("c")],
+    [lit("returnsValue", v("f"), v("v")), lit("isWrittenAs", v("v"), v("c"))]
+  ),
   // What one call site put in a parameter, told apart from what the
   // other callers passed.
   rule(
@@ -1325,18 +1993,34 @@ var RESOLUTION_RULES = [
     [v("x"), v("obj")],
     [lit("givesBack", v("x"), v("obj")), lit("objectValue", v("obj"))]
   ),
+  // A construction is the object it made, and so is any name for it.
+  // The class stays an answer too, so an instance whose site is not in
+  // the run still reads what the class stores.
+  rule(
+    "objectOf",
+    [v("site"), v("site")],
+    [lit("allocates", v("site"), v("c"))]
+  ),
+  rule(
+    "objectOf",
+    [v("o"), v("site")],
+    [
+      lit("reaches", v("o"), v("site"), VALUE_STEP),
+      lit("allocates", v("site"), v("c"))
+    ]
+  ),
   // Which calls a function, found by the name the call is written as
   // rather than by resolving every callee in the project. A caller knows
   // the function and wants its call sites, so both of these start from
   // the function. Starting from `call` instead asks what every call in
   // the project imports, which was 72% of everything derived.
   rule(
-    "callsFunction",
+    "callsNamed",
     [v("r"), v("f")],
     [lit("binds", v("c"), v("f")), lit("call", v("r"), v("c"))]
   ),
   rule(
-    "callsFunction",
+    "callsNamed",
     [v("r"), v("f")],
     [
       lit("moduleExport", v("m"), v("n"), v("f")),
@@ -1347,7 +2031,7 @@ var RESOLUTION_RULES = [
   // The same, for a language whose adapter writes the import down as a
   // declaration and the call's callee as the name referring to it.
   rule(
-    "callsFunction",
+    "callsNamed",
     [v("r"), v("f")],
     [
       lit("moduleExport", v("m"), v("n"), v("f")),
@@ -1356,6 +2040,62 @@ var RESOLUTION_RULES = [
       lit("call", v("r"), v("c"))
     ]
   ),
+  // `const f = (x) => ...` declares the name and puts the parameters on
+  // the arrow, so everything above arrives at the declaration and
+  // `paramOf` is about the arrow. One binds hop joins the two.
+  rule(
+    "callsNamed",
+    [v("r"), v("f")],
+    [lit("binds", v("g"), v("f")), lit("callsNamed", v("r"), v("g"))]
+  ),
+  // Every one of those, and the binds hop again over the whole
+  // relation, so a property holding a name for a function is reached
+  // the way it was before the two were told apart.
+  rule("callsFunction", [v("r"), v("f")], [lit("callsNamed", v("r"), v("f"))]),
+  rule(
+    "callsFunction",
+    [v("r"), v("f")],
+    [lit("binds", v("g"), v("f")), lit("callsFunction", v("r"), v("g"))]
+  ),
+  // A function written on an object, called off it: `client.get(o)`.
+  // The receiver comes from the object through `refersToObject`, not from
+  // `objectOf`: a walk from every reader of the name was most of a run.
+  rule(
+    "callsFunction",
+    [v("r"), v("f")],
+    [
+      lit("holdsProperty", v("obj"), v("n"), v("f")),
+      lit("refersToObject", v("o"), v("obj")),
+      lit("readsProperty", v("c"), v("o"), v("n")),
+      lit("call", v("r"), v("c"))
+    ]
+  ),
+  // The expressions that refer to an object literal by binding alone: the
+  // declaration written as it, a reference or import of that, and a
+  // fallback over any of those. Asked from the object, so it visits only them.
+  rule("refersToObject", [v("obj"), v("obj")], [lit("objectValue", v("obj"))]),
+  rule(
+    "refersToObject",
+    [v("x"), v("obj")],
+    [lit("refersToObject", v("y"), v("obj")), lit("binds", v("x"), v("y"))]
+  ),
+  rule(
+    "refersToObject",
+    [v("x"), v("obj")],
+    [
+      lit("refersToObject", v("y"), v("obj")),
+      lit("moduleExport", v("m"), v("n"), v("y")),
+      lit("imports", v("x"), v("m"), v("n"))
+    ]
+  ),
+  rule(
+    "refersToObject",
+    [v("x"), v("obj")],
+    [
+      lit("refersToObject", v("b"), v("obj")),
+      lit("fallbackBranch", v("x"), v("b"))
+    ]
+  ),
   // What an object contains, its base class included, so a method the base
   // declares is found on a subclass that never overrode it. A method both
   // declare gives two, and the caller decides. This is its own relation
@@ -1373,7 +2113,8 @@ var RESOLUTION_RULES = [
       lit("extends", v("cls"), v("base")),
       lit("comesTo", v("base"), v("baseCls")),
       lit("contains", v("baseCls"), v("n"), v("held"))
-    ]
+    ],
+    BASE_CLASS_RULE
   ),
   // An association is read off an instance as a property, and stating
   // it as `contains` is what puts it on the ancestry rule, so a concern
@@ -1397,6 +2138,69 @@ var RESOLUTION_RULES = [
     ],
     "constructed association"
   ),
+  // What the constructor put on the receiver. The class is the object
+  // for an instance whose own site is not in the run.
+  rule(
+    "contains",
+    [v("cls"), v("n"), v("held")],
+    [
+      lit("initializes", v("cls"), v("f")),
+      lit("storesProperty", v("f"), v("n"), v("held"))
+    ],
+    "constructor store"
+  ),
+  // What any other method of the class put there. Two methods writing
+  // one name give two rows, since nothing here orders them.
+  rule(
+    "contains",
+    [v("cls"), v("n"), v("held")],
+    [
+      lit("holdsProperty", v("cls"), v("m"), v("f")),
+      lit("storesProperty", v("f"), v("n"), v("held"))
+    ],
+    "method store"
+  ),
+  // A write through a name rather than through the receiver,
+  // `client.timeout = 5`, which lands on whatever that name refers to.
+  rule(
+    "contains",
+    [v("obj"), v("n"), v("held")],
+    [
+      lit("storesProperty", v("r"), v("n"), v("held")),
+      lit("objectOf", v("r"), v("obj"))
+    ],
+    "named receiver store"
+  ),
+  // A call written with a class's own name, which is how most languages
+  // spell a construction. A language that spells one some other way
+  // states its own rule for this, the way Ruby does for `Const.new`.
+  rule(
+    "constructsNamed",
+    [v("r"), v("cls")],
+    [lit("objectValue", v("cls")), lit("callsNamed", v("r"), v("cls"))]
+  ),
+  // Each construction is an object of its own containing what its
+  // class stores, so two sites are two objects.
+  rule(
+    "contains",
+    [v("site"), v("n"), v("held")],
+    [
+      lit("allocates", v("site"), v("cls")),
+      lit("contains", v("cls"), v("n"), v("held"))
+    ],
+    "allocated instance"
+  ),
+  // A call that makes one of a class. Every finder a pack declared is
+  // one too, so `User.find(1)` is a site the same way `User.new` is.
+  rule(
+    "allocates",
+    [v("site"), v("cls")],
+    [
+      lit("call", v("site"), v("c")),
+      lit("stepsTo", v("site"), v("cls"), INSTANCE_STEP)
+    ],
+    "allocation site"
+  ),
   // The library base a class's ancestry arrives at, however many of a
   // project's own classes sit in between. A base the run declares has a
   // node to keep walking from; one it does not has only a name.
@@ -1486,8 +2290,8 @@ var RESOLUTION_RULES = [
     ]
   ),
   // Where a name comes from, when what it refers to lives outside the
-  // source being read. A walk ends at something written out in source,
-  // so it never reaches a library's own function.
+  // source being read. A walk ends at what the source writes out, so it
+  // never reaches a library's own function; these rules do.
   rule(
     "comesFrom",
     [v("x"), v("m"), v("n")],
@@ -1501,6 +2305,28 @@ var RESOLUTION_RULES = [
       lit("imports", v("y"), v("m"), v("n"))
     ]
   ),
+  // A member read off a whole-module import: the member's own name is
+  // what the module exports, so `fastapi.APIRouter` comes from
+  // fastapi's `APIRouter`. Directly, or through a name for the module.
+  rule(
+    "comesFrom",
+    [v("x"), v("m"), v("n")],
+    [
+      lit("readsProperty", v("x"), v("ns"), v("n")),
+      lit("imports", v("ns"), v("m"), NAMESPACE_IMPORT)
+    ],
+    NAMESPACE_MEMBER_RULE
+  ),
+  rule(
+    "comesFrom",
+    [v("x"), v("m"), v("n")],
+    [
+      lit("readsProperty", v("x"), v("o"), v("n")),
+      lit("reaches", v("o"), v("ns"), VALUE_STEP),
+      lit("imports", v("ns"), v("m"), NAMESPACE_IMPORT)
+    ],
+    NAMESPACE_MEMBER_RULE
+  ),
   // Calling f ends up calling the name n that module m exports, one
   // hop through f's own body or deeper through a wrapper of a wrapper.
   // Several results is normal: a composed decorator applies them all.
@@ -1530,6 +2356,13 @@ var RESOLUTION_RULES = [
     [lit("comesTo", v("x"), v("z")), lit("func", v("z"))]
   )
 ];
+function alsoSteps(rules) {
+  return [
+    ...rules,
+    ...rules.filter((r) => r.head.relation === "hop").map((r) => ({ ...r, head: { ...r.head, relation: "stepsTo" } }))
+  ];
+}
+var RESOLUTION_RULES = alsoSteps(STATED_RULES);
 var RESOLUTION_QUESTIONS = [
   rule(
     "wantedResolves",
@@ -1552,12 +2385,55 @@ var RESOLUTION_QUESTIONS = [
     [lit("wanted", v("x")), lit("isWrittenAs", v("x"), v("z"))]
   ),
   // A call is given no `comesTo`, so this is the only way to ask what
-  // object one arrives at, and without it a demand-driven run derives
-  // `objectOf` nowhere.
+  // object one arrives at, and a demand-driven run derives `objectOf`
+  // nowhere without it. An allocation site is not one of the answers.
   rule(
     "wantedObjectOf",
     [v("x"), v("z")],
-    [lit("wanted", v("x")), lit("objectOf", v("x"), v("z"))]
+    [
+      lit("wanted", v("x")),
+      lit("objectOf", v("x"), v("z")),
+      lit("objectValue", v("z"))
+    ]
+  ),
+  // The same three questions under one allocation site, keyed by the
+  // value and the site both. An allocation site is an answer here,
+  // unlike `wantedObjectOf`, since a site is what a context is.
+  rule(
+    "wantedIsWrittenAsUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("wantedUnder", v("x"), v("c")),
+      lit("isWrittenAsUnder", v("x"), v("c"), v("z"))
+    ]
+  ),
+  // Where a class was made, for a caller about to ask a value question
+  // under each. Going through `constructsNamed` keeps the demand on the
+  // calls written with the class's name rather than on every call.
+  rule(
+    "wantedAllocatedAt",
+    [v("cls"), v("site")],
+    [
+      lit("wantedSites", v("cls")),
+      lit("constructsNamed", v("site"), v("cls")),
+      lit("allocates", v("site"), v("cls"))
+    ]
+  ),
+  rule(
+    "wantedComesToUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("wantedUnder", v("x"), v("c")),
+      lit("comesToUnder", v("x"), v("c"), v("z"))
+    ]
+  ),
+  rule(
+    "wantedObjectOfUnder",
+    [v("x"), v("c"), v("z")],
+    [
+      lit("wantedUnder", v("x"), v("c")),
+      lit("objectOfUnder", v("x"), v("c"), v("z"))
+    ]
   ),
   // The same for the function a call returns: `app.use(requireCaller(config))`
   // registers what the factory gives back, and `resolves` on the call
@@ -1574,6 +2450,19 @@ var RESOLUTION_QUESTIONS = [
     [v("p"), v("r"), v("z")],
     [lit("wanted", v("p")), lit("paramAt", v("r"), v("p"), v("z"))]
   ),
+  // The argument as the caller wrote it. A parameter given a GraphQL
+  // document has no `paramAt` answer, since that settles through
+  // `comesTo`, which stops at a function or an object.
+  rule(
+    "wantedPassesArgument",
+    [v("p"), v("r"), v("a")],
+    [lit("wanted", v("p")), lit("passesArgument", v("r"), v("p"), v("a"))]
+  ),
+  rule(
+    "wantedReturnsCall",
+    [v("f"), v("c")],
+    [lit("wanted", v("f")), lit("returnsCall", v("f"), v("c"))]
+  ),
   rule(
     "wantedComesFrom",
     [v("x"), v("m"), v("n")],
@@ -1837,35 +2726,61 @@ var RESOLUTION_QUESTIONS = [
 var ANSWER_RELATIONS = [
   ...new Set(RESOLUTION_QUESTIONS.map((r) => r.head.relation))
 ];
+var UNDER_ANSWER_RELATIONS = [
+  "wantedIsWrittenAsUnder",
+  "wantedComesToUnder",
+  "wantedObjectOfUnder"
+];
 export {
   ANSWER_RELATIONS,
   ASKING_RELATIONS,
+  BASE_CLASS_RULE,
   FACT_CONTRACT_CASES,
+  INSTANCE_STEP,
   NAMESPACE_IMPORT,
   NAMESPACE_IMPORT_NAME,
+  NAMESPACE_MEMBER_RULE,
+  NO_CONTEXT,
+  NO_CONTEXT_NAME,
   RESOLUTION_QUESTIONS,
   RESOLUTION_RULES,
   RESULT_STEP,
+  UNDER_ANSWER_RELATIONS,
+  UNDER_QUESTION_ROW_BUDGET,
+  UNDER_RUN_ROW_BUDGET,
   VALUE_STEP,
+  addPackWords,
   agreedMountPrefix,
+  allocationSitesOf,
+  alsoSteps,
+  answersByKey,
   askResolution,
+  askResolutionUnder,
   calleeOutcomeOf,
   calleeOutcomes,
   checkFactContract,
+  comesToUnder,
   couldBeSettled,
   explainResolutionProof,
   explainResolvedKey,
+  isWrittenAsUnder,
   joinMountedPath,
   mountPathsOf,
   nodeOfKey,
+  objectOfUnder,
   placeholderValues,
   queryFacts,
   renderExplanation,
   resolutionProgram,
+  resolutionUnderProgram,
   singleAnswers,
   startsAtName,
+  underQuestionSpend,
   valueLeftByWrites,
   writesRunInOrder,
   writtenSourcesOf,
-  writtenValueOf
+  writtenValueOf,
+  writtenValueUnder,
+  writtenValuesByKey,
+  writtenValuesOf
 };