@suss/resolution 0.30.0 → 0.31.0

package/dist/index.cjs

@@ -22,34 +22,52 @@ var index_exports = {};
 __export(index_exports, {
   ANSWER_RELATIONS: () => ANSWER_RELATIONS,
   ASKING_RELATIONS: () => ASKING_RELATIONS,
+  BASE_CLASS_RULE: () => BASE_CLASS_RULE,
   FACT_CONTRACT_CASES: () => FACT_CONTRACT_CASES,
+  INSTANCE_STEP: () => INSTANCE_STEP,
   NAMESPACE_IMPORT: () => NAMESPACE_IMPORT,
   NAMESPACE_IMPORT_NAME: () => NAMESPACE_IMPORT_NAME,
+  NAMESPACE_MEMBER_RULE: () => NAMESPACE_MEMBER_RULE,
+  NO_CONTEXT: () => NO_CONTEXT,
+  NO_CONTEXT_NAME: () => NO_CONTEXT_NAME,
   RESOLUTION_QUESTIONS: () => RESOLUTION_QUESTIONS,
   RESOLUTION_RULES: () => RESOLUTION_RULES,
   RESULT_STEP: () => RESULT_STEP,
+  UNDER_ANSWER_RELATIONS: () => UNDER_ANSWER_RELATIONS,
   VALUE_STEP: () => VALUE_STEP,
+  addPackWords: () => addPackWords,
   agreedMountPrefix: () => agreedMountPrefix,
+  allocationSitesOf: () => allocationSitesOf,
+  alsoSteps: () => alsoSteps,
+  answersByKey: () => answersByKey,
   askResolution: () => askResolution,
+  askResolutionUnder: () => askResolutionUnder,
   calleeOutcomeOf: () => calleeOutcomeOf,
   calleeOutcomes: () => calleeOutcomes,
   checkFactContract: () => checkFactContract,
+  comesToUnder: () => comesToUnder,
   couldBeSettled: () => couldBeSettled,
   explainResolutionProof: () => explainResolutionProof,
   explainResolvedKey: () => explainResolvedKey,
+  isWrittenAsUnder: () => isWrittenAsUnder,
   joinMountedPath: () => joinMountedPath,
   mountPathsOf: () => mountPathsOf,
   nodeOfKey: () => nodeOfKey,
+  objectOfUnder: () => objectOfUnder,
   placeholderValues: () => placeholderValues,
   queryFacts: () => queryFacts,
   renderExplanation: () => renderExplanation,
   resolutionProgram: () => resolutionProgram,
+  resolutionUnderProgram: () => resolutionUnderProgram,
   singleAnswers: () => singleAnswers,
   startsAtName: () => startsAtName,
   valueLeftByWrites: () => valueLeftByWrites,
   writesRunInOrder: () => writesRunInOrder,
   writtenSourcesOf: () => writtenSourcesOf,
-  writtenValueOf: () => writtenValueOf
+  writtenValueOf: () => writtenValueOf,
+  writtenValueUnder: () => writtenValueUnder,
+  writtenValuesByKey: () => writtenValuesByKey,
+  writtenValuesOf: () => writtenValuesOf
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -57,6 +75,8 @@ module.exports = __toCommonJS(index_exports);
 var import_datalog = require("@suss/datalog");
 var ASKING_RELATIONS = [
   "wanted",
+  "wantedUnder",
+  "wantedSites",
   "wantedOrigin",
   "wantedCallOrigin",
   "wantedExportsOf",
@@ -66,8 +86,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;
   }
@@ -76,10 +100,16 @@ function resolutionProgram(languageRules = NO_LANGUAGE_RULES) {
     ...languageRules,
     ...RESOLUTION_QUESTIONS
   ];
-  const program = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? { rules, demandDriven: [], demands: [] } : (0, import_datalog.deriveOnDemand)(rules, ANSWER_RELATIONS);
-  programs.set(languageRules, program);
+  const program = process.env.SUSS_RESOLUTION_ON_DEMAND === "0" ? { rules, demandDriven: [], demands: [] } : (0, import_datalog.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 [];
@@ -116,6 +146,29 @@ function askResolution(db, keys, asking = "wanted", program = resolutionProgram(
     (0, import_datalog.clearRelations)(db, program.rules, forget);
   }
 }
+var askedUnderByDb = /* @__PURE__ */ new WeakMap();
+function askResolutionUnder(db, pairs, program = resolutionUnderProgram()) {
+  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((0, import_datalog.tupleKey)([key, site]))
+  );
+  if (fresh.length === 0) {
+    return;
+  }
+  for (const [key, site] of fresh) {
+    asked.add((0, import_datalog.tupleKey)([key, site]));
+    db.add("wantedUnder", [key, site]);
+  }
+  (0, import_datalog.evaluate)(db, program.rules);
+  const forget = queryFacts(program);
+  if (forget.length > 0) {
+    (0, import_datalog.clearRelations)(db, program.rules, forget);
+  }
+}
 
 // src/callee.ts
 var UNDECLARED = { kind: "undeclared" };
@@ -544,6 +597,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`
   }),
@@ -560,7 +619,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" && (0, import_datalog2.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`] : []
@@ -639,7 +698,8 @@ var CHAIN_RELATIONS = /* @__PURE__ */ new Set([
   "isWrittenAs",
   "comesFrom",
   "reaches",
-  "stepsTo"
+  "stepsTo",
+  "hop"
 ]);
 function inlineChain(proof, state) {
   const explained = explainResolutionProof(proof, {
@@ -695,6 +755,17 @@ function importStep(proof, state) {
     assumptions: []
   };
 }
+function namespaceMemberStep(proof, state) {
+  const [x, module2, name] = proof.tuple;
+  return {
+    from: x,
+    to: module2,
+    rule: NAMESPACE_MEMBER_RULE,
+    reason: `${state.describe(x)} reads ${String(name)} off ${state.describe(module2)}, which is imported whole`,
+    notes: [],
+    assumptions: []
+  };
+}
 var flattenInto = (proof, state) => {
   if (proof.kind === "truncated") {
     state.truncated = true;
@@ -704,7 +775,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;
   }
@@ -715,6 +786,10 @@ var flattenInto = (proof, state) => {
     return;
   }
   if (relation === "comesFrom") {
+    if ((0, import_datalog2.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));
@@ -891,6 +966,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
 var import_datalog3 = require("@suss/datalog");
 function explainResolvedKey(options) {
@@ -946,7 +1052,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]);
@@ -958,9 +1064,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]);
     }
@@ -978,6 +1090,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);
@@ -1008,23 +1142,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
@@ -1032,38 +1201,61 @@ var import_datalog4 = require("@suss/datalog");
 var VALUE_STEP = (0, import_datalog4.constant)("value");
 var NAMESPACE_IMPORT_NAME = "*";
 var NAMESPACE_IMPORT = (0, import_datalog4.constant)(NAMESPACE_IMPORT_NAME);
+var NAMESPACE_MEMBER_RULE = "namespace member";
+var BASE_CLASS_RULE = "base class";
+var INSTANCE_STEP = (0, import_datalog4.constant)("instance");
 var RESULT_STEP = (0, import_datalog4.constant)("result");
-var RESOLUTION_RULES = [
+var NO_CONTEXT_NAME = "none";
+var NO_CONTEXT = (0, import_datalog4.constant)(NO_CONTEXT_NAME);
+var STEP_LATTICE = [
+  { soFar: VALUE_STEP, next: (0, import_datalog4.variable)("kind"), took: (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), VALUE_STEP],
     [(0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), VALUE_STEP],
     [(0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "hop",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), VALUE_STEP],
+    [(0, import_datalog4.lit)("mayHold", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("writesAllStated", (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("b"), VALUE_STEP],
     [(0, import_datalog4.lit)("fallbackBranch", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("b"))],
     "fallback"
   ),
   // An import steps to what the module exports under that name.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("value"), VALUE_STEP],
     [
       (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
@@ -1097,8 +1289,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.
   (0, import_datalog4.rule)(
-    "stepsTo",
-    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    "hop",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), INSTANCE_STEP],
     [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
       (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("cls")),
@@ -1106,12 +1298,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.
+  (0, import_datalog4.rule)(
+    "hop",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog4.lit)("instanceOf", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "stepsTo",
-    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    "hop",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), INSTANCE_STEP],
     [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
       (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m")),
@@ -1128,8 +1329,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.
   (0, import_datalog4.rule)(
-    "stepsTo",
-    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    "hop",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), INSTANCE_STEP],
     [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
       (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m")),
@@ -1146,8 +1347,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.
   (0, import_datalog4.rule)(
-    "stepsTo",
-    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
+    "hop",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), INSTANCE_STEP],
     [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
       (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n")),
@@ -1157,10 +1358,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.
+  (0, import_datalog4.rule)(
+    "hop",
+    [(0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("r"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("entersAs", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("entersAsSelf", (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n"))
+    ],
+    "context manager returns self"
+  ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("a"), VALUE_STEP],
     [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")),
@@ -1174,7 +1389,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.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("a"), VALUE_STEP],
     [
       (0, import_datalog4.lit)("calleeName", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n")),
@@ -1188,44 +1403,441 @@ var RESOLUTION_RULES = [
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
   (0, import_datalog4.rule)(
-    "stepsTo",
+    "hop",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("ret"), RESULT_STEP],
     [(0, import_datalog4.lit)("invokes", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")), (0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "hop",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), RESULT_STEP],
+    [
+      (0, import_datalog4.lit)("invokes", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("returnsClass", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
     "reaches",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("kind")],
     [(0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("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 }) => (0, import_datalog4.rule)(
+      "reaches",
+      [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), took],
+      [
+        (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), soFar),
+        (0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)("context", [NO_CONTEXT], [], "no context"),
+  (0, import_datalog4.rule)(
+    "context",
+    [(0, import_datalog4.variable)("site")],
+    [(0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("kind")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("hop", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("kind"))],
+    "under one hop"
+  ),
+  ...STEP_LATTICE.map(
+    ({ soFar, next, took }) => (0, import_datalog4.rule)(
+      "reachesUnder",
+      [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), took],
+      [
+        (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("c2"), soFar),
+        (0, import_datalog4.lit)("hop", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "reaches",
-    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("kind")],
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c"), VALUE_STEP],
+    [(0, import_datalog4.lit)("instanceOf", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("cls")), (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("cls"))],
+    "receiver is the site"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")],
     [
-      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), VALUE_STEP),
-      (0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("kind"))
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")),
+      (0, import_datalog4.lit)("instanceOf", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("site")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls"))],
+    "site is its own object"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("site")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls"))
+    ],
+    "name of a site"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("obj")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("obj"))
+    ],
+    "written object under a context"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("obj")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("c2"), RESULT_STEP),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("obj"))
+    ],
+    "returned object under a context"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), NO_CONTEXT, (0, import_datalog4.variable)("cls")],
+    [
+      (0, import_datalog4.lit)(
+        "reachesUnder",
+        (0, import_datalog4.variable)("o"),
+        NO_CONTEXT,
+        (0, import_datalog4.variable)("cls"),
+        NO_CONTEXT,
+        INSTANCE_STEP
+      ),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("cls"))
+    ],
+    "class reached with no context"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), NO_CONTEXT, (0, import_datalog4.variable)("cls")],
+    [(0, import_datalog4.lit)("instanceOf", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("cls"))],
+    "receiver class with no context"
+  ),
+  (0, import_datalog4.rule)(
+    "objectOfUnder",
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("held"), (0, import_datalog4.variable)("site"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("site")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ],
+    "property read at a site"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("held"), (0, import_datalog4.variable)("c"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("obj")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("obj")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ],
+    "property read off an object"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("held"), (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("kind")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("site")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ],
+    "reached property read at a site"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("held"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("obj")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("obj")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("c3"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("i"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("entersUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c3")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("i"), (0, import_datalog4.variable)("a"))
+    ],
+    "argument under a context"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("c3"), VALUE_STEP],
+    [
+      (0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("paramNamed", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("entersUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c3")),
+      (0, import_datalog4.lit)("callKeywordArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("a"))
+    ],
+    "keyword argument under a context"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("c3"), (0, import_datalog4.variable)("kind")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")),
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("i"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("entersUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("c3")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("i"), (0, import_datalog4.variable)("a"))
+    ],
+    "reached argument under a context"
+  ),
+  (0, import_datalog4.rule)(
+    "reachesUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("c3"), (0, import_datalog4.variable)("kind")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("kind")),
+      (0, import_datalog4.lit)("paramNamed", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("entersUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c2"), (0, import_datalog4.variable)("c3")),
+      (0, import_datalog4.lit)("callKeywordArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "entersUnder",
+    [(0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("ctor"), (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("caller")],
+    [
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("runsConstructor", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("ctor")),
+      (0, import_datalog4.lit)("callUnder", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("caller"))
+    ],
+    "construction enters its constructor"
+  ),
+  (0, import_datalog4.rule)(
+    "entersUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("caller")],
+    [
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cal")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("cal"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("caller"), (0, import_datalog4.variable)("site")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("callUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "entersUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c")],
+    [
+      (0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("callsNamed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("callUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))
+    ],
+    "named call enters under the site it is made in"
+  ),
+  (0, import_datalog4.rule)(
+    "entersUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"), NO_CONTEXT, (0, import_datalog4.variable)("caller")],
+    [
+      (0, import_datalog4.lit)("callsFunction", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("callUnder", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "runsConstructor",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("initializes", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("f"))]
+  ),
+  (0, import_datalog4.rule)(
+    "runsConstructor",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("f")],
+    [
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("base")),
+      (0, import_datalog4.lit)("runsConstructor", (0, import_datalog4.variable)("base"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "reaches",
-    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), RESULT_STEP],
+    "callInBody",
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")],
+    [(0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))]
+  ),
+  (0, import_datalog4.rule)(
+    "callInBody",
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")],
+    [(0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "callUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("site")],
+    [
+      (0, import_datalog4.lit)("callInBody", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls"))
+    ],
+    "call in a method"
+  ),
+  (0, import_datalog4.rule)(
+    "callUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("site")],
     [
-      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), RESULT_STEP),
-      (0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"), VALUE_STEP)
+      (0, import_datalog4.lit)("callInBody", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("initializes", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "callUnder",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")],
+    [
+      (0, import_datalog4.lit)("callOutsideMethod", (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("callInBody", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("entersUnder", (0, import_datalog4.variable)("into"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c4"))
+    ],
+    "call in a function entered under a site"
+  ),
+  (0, import_datalog4.rule)(
+    "callUnder",
+    [(0, import_datalog4.variable)("r"), NO_CONTEXT],
+    [(0, import_datalog4.lit)("callOutsideMethod", (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "isWrittenAsUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("writtenValue", (0, import_datalog4.variable)("x"))]
+  ),
+  (0, import_datalog4.rule)(
+    "isWrittenAsUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("x"))]
+  ),
+  (0, import_datalog4.rule)(
+    "isWrittenAsUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("writtenValue", (0, import_datalog4.variable)("z"))
     ]
   ),
   (0, import_datalog4.rule)(
-    "reaches",
-    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), RESULT_STEP],
+    "isWrittenAsUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("z"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("x"))]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("context", (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("x"))]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("z"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), RESULT_STEP),
-      (0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"), RESULT_STEP)
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), VALUE_STEP),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("z"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), INSTANCE_STEP),
+      (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("z"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "comesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("reachesUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("c2"), INSTANCE_STEP),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("z"))
     ]
   ),
   // What a value comes down to: the walk that never ran a call, stopped
@@ -1243,6 +1855,18 @@ var RESOLUTION_RULES = [
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
     [(0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), VALUE_STEP), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("z"))]
   ),
+  // An instance walk stops the same way, so a method read off
+  // `new App()` still finds what the class declares.
+  (0, import_datalog4.rule)(
+    "comesTo",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), INSTANCE_STEP), (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("z"))]
+  ),
+  (0, import_datalog4.rule)(
+    "comesTo",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), INSTANCE_STEP), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("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.
@@ -1283,6 +1907,13 @@ var RESOLUTION_RULES = [
       (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("ret"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "returnsCall",
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")],
+    [(0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("v")), (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("v"), (0, import_datalog4.variable)("c"))]
+  ),
   // What one call site put in a parameter, told apart from what the
   // other callers passed.
   (0, import_datalog4.rule)(
@@ -1380,18 +2011,34 @@ var RESOLUTION_RULES = [
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("obj")],
     [(0, import_datalog4.lit)("givesBack", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("obj")), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "objectOf",
+    [(0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("site")],
+    [(0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c"))]
+  ),
+  (0, import_datalog4.rule)(
+    "objectOf",
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("site")],
+    [
+      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("site"), VALUE_STEP),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
-    "callsFunction",
+    "callsNamed",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
     [(0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("f")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))]
   ),
   (0, import_datalog4.rule)(
-    "callsFunction",
+    "callsNamed",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
     [
       (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("f")),
@@ -1402,7 +2049,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.
   (0, import_datalog4.rule)(
-    "callsFunction",
+    "callsNamed",
     [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
     [
       (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("f")),
@@ -1411,6 +2058,36 @@ var RESOLUTION_RULES = [
       (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "callsNamed",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("f")), (0, import_datalog4.lit)("callsNamed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)("callsFunction", [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")], [(0, import_datalog4.lit)("callsNamed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f"))]),
+  (0, import_datalog4.rule)(
+    "callsFunction",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("f")), (0, import_datalog4.lit)("callsFunction", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("g"))]
+  ),
+  // A function written on an object, called off it: `client.get(o)`.
+  // Every rule above joins on a name the callee binds to, and a read of
+  // a property binds to nothing.
+  (0, import_datalog4.rule)(
+    "callsFunction",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
+    [
+      (0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("obj")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))
+    ]
+  ),
   // 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
@@ -1428,7 +2105,8 @@ var RESOLUTION_RULES = [
       (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("base")),
       (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("base"), (0, import_datalog4.variable)("baseCls")),
       (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("baseCls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("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
@@ -1452,6 +2130,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.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
+    [
+      (0, import_datalog4.lit)("initializes", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("storesProperty", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
+    [
+      (0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("storesProperty", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ],
+    "method store"
+  ),
+  // A write through a name rather than through the receiver,
+  // `client.timeout = 5`, which lands on whatever that name refers to.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
+    [
+      (0, import_datalog4.lit)("storesProperty", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("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`.
+  (0, import_datalog4.rule)(
+    "constructsNamed",
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls")],
+    [(0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("cls")), (0, import_datalog4.lit)("callsNamed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"))]
+  ),
+  // Each construction is an object of its own containing what its
+  // class stores, so two sites are two objects.
+  (0, import_datalog4.rule)(
+    "contains",
+    [(0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
+    [
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("contains", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "allocates",
+    [(0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")],
+    [
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("stepsTo", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("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.
@@ -1541,8 +2282,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.
   (0, import_datalog4.rule)(
     "comesFrom",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
@@ -1556,6 +2297,28 @@ var RESOLUTION_RULES = [
       (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "comesFrom",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("ns"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("ns"), (0, import_datalog4.variable)("m"), NAMESPACE_IMPORT)
+    ],
+    NAMESPACE_MEMBER_RULE
+  ),
+  (0, import_datalog4.rule)(
+    "comesFrom",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("ns"), VALUE_STEP),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("ns"), (0, import_datalog4.variable)("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.
@@ -1585,6 +2348,13 @@ var RESOLUTION_RULES = [
     [(0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")), (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("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 = [
   (0, import_datalog4.rule)(
     "wantedResolves",
@@ -1607,12 +2377,55 @@ var RESOLUTION_QUESTIONS = [
     [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("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.
   (0, import_datalog4.rule)(
     "wantedObjectOf",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
-    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
+    [
+      (0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "wantedIsWrittenAsUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("wantedUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("isWrittenAsUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "wantedAllocatedAt",
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("site")],
+    [
+      (0, import_datalog4.lit)("wantedSites", (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("constructsNamed", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("allocates", (0, import_datalog4.variable)("site"), (0, import_datalog4.variable)("cls"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "wantedComesToUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("wantedUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("comesToUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"))
+    ]
+  ),
+  (0, import_datalog4.rule)(
+    "wantedObjectOfUnder",
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z")],
+    [
+      (0, import_datalog4.lit)("wantedUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("objectOfUnder", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("z"))
+    ]
   ),
   // The same for the function a call returns: `app.use(requireCaller(config))`
   // registers what the factory gives back, and `resolves` on the call
@@ -1629,6 +2442,19 @@ var RESOLUTION_QUESTIONS = [
     [(0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("z")],
     [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("p")), (0, import_datalog4.lit)("paramAt", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("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.
+  (0, import_datalog4.rule)(
+    "wantedPassesArgument",
+    [(0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("a")],
+    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("p")), (0, import_datalog4.lit)("passesArgument", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a"))]
+  ),
+  (0, import_datalog4.rule)(
+    "wantedReturnsCall",
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")],
+    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("f")), (0, import_datalog4.lit)("returnsCall", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"))]
+  ),
   (0, import_datalog4.rule)(
     "wantedComesFrom",
     [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
@@ -1892,36 +2718,59 @@ var RESOLUTION_QUESTIONS = [
 var ANSWER_RELATIONS = [
   ...new Set(RESOLUTION_QUESTIONS.map((r) => r.head.relation))
 ];
+var UNDER_ANSWER_RELATIONS = [
+  "wantedIsWrittenAsUnder",
+  "wantedComesToUnder",
+  "wantedObjectOfUnder"
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,
   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,
   valueLeftByWrites,
   writesRunInOrder,
   writtenSourcesOf,
-  writtenValueOf
+  writtenValueOf,
+  writtenValueUnder,
+  writtenValuesByKey,
+  writtenValuesOf
 });