@suss/resolution 0.27.0 → 0.29.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ANSWER_RELATIONS: () => ANSWER_RELATIONS,
+  ASKING_RELATIONS: () => ASKING_RELATIONS,
   FACT_CONTRACT_CASES: () => FACT_CONTRACT_CASES,
   NAMESPACE_IMPORT: () => NAMESPACE_IMPORT,
   NAMESPACE_IMPORT_NAME: () => NAMESPACE_IMPORT_NAME,
@@ -29,19 +30,289 @@ __export(index_exports, {
   RESULT_STEP: () => RESULT_STEP,
   VALUE_STEP: () => VALUE_STEP,
   agreedMountPrefix: () => agreedMountPrefix,
+  askResolution: () => askResolution,
+  calleeOutcomeOf: () => calleeOutcomeOf,
+  calleeOutcomes: () => calleeOutcomes,
   checkFactContract: () => checkFactContract,
+  couldBeSettled: () => couldBeSettled,
   explainResolutionProof: () => explainResolutionProof,
   explainResolvedKey: () => explainResolvedKey,
   joinMountedPath: () => joinMountedPath,
   mountPathsOf: () => mountPathsOf,
   nodeOfKey: () => nodeOfKey,
   placeholderValues: () => placeholderValues,
+  queryFacts: () => queryFacts,
   renderExplanation: () => renderExplanation,
+  resolutionProgram: () => resolutionProgram,
   singleAnswers: () => singleAnswers,
+  startsAtName: () => startsAtName,
+  valueLeftByWrites: () => valueLeftByWrites,
+  writesRunInOrder: () => writesRunInOrder,
+  writtenSourcesOf: () => writtenSourcesOf,
   writtenValueOf: () => writtenValueOf
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/program.ts
+var import_datalog = require("@suss/datalog");
+var ASKING_RELATIONS = [
+  "wanted",
+  "wantedOrigin",
+  "wantedCallOrigin",
+  "wantedExportsOf",
+  "wantedSubject",
+  "wantedAnchor",
+  "wantedAncestry"
+];
+var NO_LANGUAGE_RULES = [];
+var programs = /* @__PURE__ */ new WeakMap();
+function resolutionProgram(languageRules = NO_LANGUAGE_RULES) {
+  const built = programs.get(languageRules);
+  if (built !== void 0) {
+    return built;
+  }
+  const rules = [
+    ...RESOLUTION_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);
+  return program;
+}
+function queryFacts(program) {
+  if (program.demandDriven.length === 0) {
+    return [];
+  }
+  return [...program.demandDriven, ...ASKING_RELATIONS];
+}
+var askedByDb = /* @__PURE__ */ new WeakMap();
+function askedOf(db, asking) {
+  let byRelation = askedByDb.get(db);
+  if (byRelation === void 0) {
+    byRelation = /* @__PURE__ */ new Map();
+    askedByDb.set(db, byRelation);
+  }
+  let asked = byRelation.get(asking);
+  if (asked === void 0) {
+    asked = /* @__PURE__ */ new Set();
+    byRelation.set(asking, asked);
+  }
+  return asked;
+}
+function askResolution(db, keys, asking = "wanted", program = resolutionProgram()) {
+  const asked = askedOf(db, asking);
+  const fresh = [...keys].filter((key) => !asked.has(key));
+  if (fresh.length === 0) {
+    return;
+  }
+  for (const key of fresh) {
+    asked.add(key);
+    db.add(asking, [key]);
+  }
+  (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" };
+var UNSETTLED = { kind: "unsettled" };
+var OUTSIDE_RUN = { kind: "outsideRun" };
+function calleeOutcomes(db, keys, program = resolutionProgram()) {
+  askAboutSources(db, keys, program);
+  const reading = new Reading(db);
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    outcomes.set(key, reading.outcomeOf(key));
+  }
+  return outcomes;
+}
+function calleeOutcomeOf(db, key, program = resolutionProgram()) {
+  return calleeOutcomes(db, [key], program).get(key) ?? UNDECLARED;
+}
+function askAboutSources(db, keys, program) {
+  let wave = [...new Set(keys)];
+  const asked = new Set(wave);
+  while (wave.length > 0) {
+    askResolution(db, wave, "wanted", program);
+    const next = [];
+    for (const key of wave) {
+      if (!decidedByCallers(db, key) && answersFor(db, key).length > 0) {
+        continue;
+      }
+      for (const source of sourcesOf(db, key)) {
+        if (!asked.has(source)) {
+          asked.add(source);
+          next.push(source);
+        }
+      }
+    }
+    wave = next;
+  }
+}
+function couldBeSettled(db, key) {
+  return db.has("func", [key]) || db.has("objectValue", [key]) || sourcesOf(db, key).length > 0;
+}
+function sourcesOf(db, key) {
+  const base = db.lookup("readsProperty", 0, key)[0];
+  if (base !== void 0) {
+    return [String(base[1])];
+  }
+  const call = db.lookup("call", 0, key)[0];
+  if (call !== void 0) {
+    return [String(call[1])];
+  }
+  return writtenSourcesOf(db, key);
+}
+var WRITE_RELATIONS = ["binds", "endsHolding", "mayHold"];
+function writtenSourcesOf(db, key) {
+  const found = [];
+  for (const relation of WRITE_RELATIONS) {
+    for (const row of db.lookup(relation, 0, key)) {
+      found.push(String(row[1]));
+    }
+  }
+  return found;
+}
+function answersFor(db, key) {
+  const found = /* @__PURE__ */ new Map();
+  for (const row of db.lookup("wantedComesTo", 0, key)) {
+    const answer = String(row[1]);
+    if (db.has("func", [answer])) {
+      found.set(answer, { kind: "function", key: answer });
+      continue;
+    }
+    if (db.has("objectValue", [answer])) {
+      found.set(answer, { kind: "object", key: answer });
+    }
+  }
+  return [...found.values()];
+}
+function outcomeKey(outcome) {
+  if (outcome.kind === "function" || outcome.kind === "object") {
+    return `${outcome.kind}:${outcome.key}`;
+  }
+  return outcome.kind;
+}
+var THROUGH_BASE = {
+  function: UNDECLARED,
+  object: UNDECLARED
+};
+var THROUGH_CALL = {
+  function: UNSETTLED,
+  object: UNSETTLED
+};
+var Reading = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  memo = /* @__PURE__ */ new Map();
+  walking = /* @__PURE__ */ new Set();
+  outcomeOf(key) {
+    return this.walk(key).outcome;
+  }
+  walk(key) {
+    const known = this.memo.get(key);
+    if (known !== void 0) {
+      return { outcome: known, looped: false };
+    }
+    if (this.walking.has(key)) {
+      return { outcome: UNDECLARED, looped: true };
+    }
+    this.walking.add(key);
+    const found = this.decide(key);
+    this.walking.delete(key);
+    if (!found.looped) {
+      this.memo.set(key, found.outcome);
+    }
+    return found;
+  }
+  decide(key) {
+    if (decidedByCallers(this.db, key)) {
+      return this.fromWrites(key);
+    }
+    const answers = answersFor(this.db, key);
+    if (answers.length > 1) {
+      return {
+        outcome: { kind: "severalSources", sources: answers.map(outcomeKey) },
+        looped: false
+      };
+    }
+    const only = answers[0];
+    if (only !== void 0) {
+      return { outcome: only, looped: false };
+    }
+    return this.refusal(key);
+  }
+  refusal(key) {
+    const base = this.db.lookup("readsProperty", 0, key)[0];
+    if (base !== void 0) {
+      return this.through(THROUGH_BASE, String(base[1]));
+    }
+    const call = this.db.lookup("call", 0, key)[0];
+    if (call !== void 0) {
+      return this.through(THROUGH_CALL, String(call[1]));
+    }
+    return this.fromWrites(key);
+  }
+  through(table, source) {
+    const found = this.walk(source);
+    return {
+      outcome: table[found.outcome.kind] ?? found.outcome,
+      looped: found.looped
+    };
+  }
+  /**
+   * What the writes to a name, and the arguments a call put in a
+   * parameter, agree the value is. A source that says nothing is left
+   * out, so a name narrowed through a second name keeps the outcome it
+   * started with rather than counting as a second source.
+   */
+  fromWrites(key) {
+    const found = /* @__PURE__ */ new Map();
+    let looped = false;
+    for (const source of writtenSourcesOf(this.db, key)) {
+      const from = this.walk(source);
+      looped = looped || from.looped;
+      if (from.outcome.kind !== "undeclared") {
+        found.set(outcomeKey(from.outcome), from.outcome);
+      }
+    }
+    if (isParameter(this.db, key)) {
+      found.set("callerSupplied", { kind: "callerSupplied", key });
+    }
+    if (found.size > 1) {
+      return {
+        outcome: { kind: "severalSources", sources: [...found.keys()] },
+        looped
+      };
+    }
+    const only = [...found.values()][0];
+    return { outcome: only ?? whereItCameFrom(this.db, key), looped };
+  }
+};
+function isParameter(db, key) {
+  return db.lookup("paramNamed", 2, key).length > 0 || db.lookup("paramOf", 2, key).length > 0;
+}
+function decidedByCallers(db, key) {
+  return isParameter(db, key) && db.lookup("binds", 0, key).length === 0;
+}
+function whereItCameFrom(db, key) {
+  for (const row of db.lookup("imports", 0, key)) {
+    if (db.lookup("exportsAs", 0, String(row[1])).length === 0) {
+      return OUTSIDE_RUN;
+    }
+  }
+  if (db.has("writtenValue", [key])) {
+    return OUTSIDE_RUN;
+  }
+  return db.has("writesUnstated", [key]) ? UNSETTLED : UNDECLARED;
+}
+
 // src/contract.ts
 var distinct = (values) => new Set(values).size;
 var RELATIONS_THAT_CAN_CROSS = ["imports", "binds", "reExports"];
@@ -236,12 +507,12 @@ function checkFactContract(sources, emit, options = {}) {
 }
 
 // src/explain.ts
-var import_datalog = require("@suss/datalog");
+var import_datalog2 = require("@suss/datalog");
 function exportTrail(proof, describe) {
   if (proof.kind !== "derived") {
     return [];
   }
-  const name = (0, import_datalog.ruleLabel)(proof.rule);
+  const name = (0, import_datalog2.ruleLabel)(proof.rule);
   if (name === "re-export") {
     const [m, n, m2, n2] = proof.premises[0].tuple;
     return [
@@ -317,6 +588,38 @@ var DEFAULT_PHRASES = {
       ]
     };
   },
+  "declared finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const base = String(premises[4].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} on ${describe(tuple[1])}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} on a class extending ${base} gives back one of that class`
+      ]
+    };
+  },
+  "declared argument finder": ({ tuple, premises, describe }) => {
+    const method = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[1]);
+    const base = String(premises[3].tuple[0]);
+    return {
+      reason: `${describe(tuple[0])} calls ${method} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${method} with a class extending ${base} at argument ${position} gives back one of that class`
+      ]
+    };
+  },
+  "declared import finder": ({ tuple, premises, describe }) => {
+    const module2 = String(premises[1].tuple[1]);
+    const name = String(premises[1].tuple[2]);
+    const position = String(premises[2].tuple[2]);
+    return {
+      reason: `${describe(tuple[0])} calls ${name} from ${module2} with ${describe(tuple[1])} at argument ${position}, which gives back one of it`,
+      assumptions: [
+        `a pack declares that ${name} from ${module2} gives back one of the class at argument ${position}`
+      ]
+    };
+  },
   "call result": ({ tuple, premises, describe, inline }) => {
     const invokes = premises[0];
     const invoked = invokes.tuple[1];
@@ -352,7 +655,7 @@ function inlineChain(proof, state) {
   return explained.steps.map((step) => step.reason);
 }
 function stepFrom(proof, state) {
-  const name = (0, import_datalog.ruleLabel)(proof.rule);
+  const name = (0, import_datalog2.ruleLabel)(proof.rule);
   const phrase = state.phrases[name];
   const from = proof.tuple[0];
   const to = proof.tuple[1];
@@ -521,6 +824,47 @@ function pathsOf(edges, memo, childId, visiting) {
   return result;
 }
 
+// src/nameReads.ts
+function writesRunInOrder(scope, name, writes, rules) {
+  const last = writes[writes.length - 1];
+  if (scope === null || last === void 0) {
+    return false;
+  }
+  if (!writes.every((write) => write.direct)) {
+    return false;
+  }
+  return !isReadBefore(scope, name, last.at.startIndex, rules);
+}
+function isReadBefore(scope, name, position, rules) {
+  let found = false;
+  const visit = (node) => {
+    if (found || node.startIndex >= position) {
+      return;
+    }
+    if (rules.laterBodies.has(node.type)) {
+      return;
+    }
+    if (rules.nameTypes.has(node.type) && node.text === name) {
+      found = rules.isRead(node);
+      return;
+    }
+    for (const child of rules.childrenOf(node)) {
+      visit(child);
+    }
+  };
+  for (const child of rules.childrenOf(scope)) {
+    visit(child);
+  }
+  return found;
+}
+function startsAtName(node, name, rules) {
+  if (rules.nameTypes.has(node.type)) {
+    return node.text === name;
+  }
+  const inner = rules.readFirst(node);
+  return inner !== null && startsAtName(inner, name, rules);
+}
+
 // src/nodeKey.ts
 var SPAN_KEY = /^(.*):(\d+)-(\d+)$/;
 function nodeOfKey(rootsByFile, key) {
@@ -548,10 +892,10 @@ function nodeOfKey(rootsByFile, key) {
 }
 
 // src/session.ts
-var import_datalog2 = require("@suss/datalog");
+var import_datalog3 = require("@suss/datalog");
 function explainResolvedKey(options) {
   const { db, rules, key, locate, displayPath } = options;
-  const proofDb = new import_datalog2.Database();
+  const proofDb = new import_datalog3.Database();
   let baseFacts = 0;
   for (const relation of db.relationNames()) {
     for (const tuple of db.facts(relation)) {
@@ -560,7 +904,7 @@ function explainResolvedKey(options) {
     }
   }
   const started = performance.now();
-  (0, import_datalog2.evaluate)(proofDb, rules, import_datalog2.witnesses);
+  (0, import_datalog3.evaluate)(proofDb, rules, import_datalog3.witnesses);
   const evaluateMs = performance.now() - started;
   const derivedFacts = proofDb.relationNames().reduce((count, relation) => count + proofDb.size(relation), 0) - baseFacts;
   const targets = new Set(
@@ -570,7 +914,7 @@ function explainResolvedKey(options) {
     return null;
   }
   const target = [...targets][0];
-  const proof = (0, import_datalog2.proofOf)(
+  const proof = (0, import_datalog3.proofOf)(
     proofDb,
     "resolves",
     [key, target],
@@ -634,6 +978,35 @@ function withoutPlaceholders(answers, placeholders) {
   return kept;
 }
 
+// src/writes.ts
+function valueLeftByWrites(writes, ordered) {
+  const deciding = writes.filter((write) => !write.narrowsName);
+  const left = deciding.length === 0 ? writes : deciding;
+  if (left.some((write) => write.value === null)) {
+    return null;
+  }
+  if (ordered) {
+    return left[left.length - 1]?.value ?? null;
+  }
+  return sharedConstruction(left);
+}
+function sharedConstruction(writes) {
+  let settled = null;
+  for (const write of writes) {
+    if (write.placeholder) {
+      continue;
+    }
+    if (write.construction === null) {
+      return null;
+    }
+    if (settled !== null && write.construction !== settled.construction) {
+      return null;
+    }
+    settled = write;
+  }
+  return settled?.value ?? null;
+}
+
 // src/writtenValue.ts
 function writtenValueOf(db, key, ask) {
   const placeholders = placeholderValues(db);
@@ -655,336 +1028,387 @@ function writtenValueOf(db, key, ask) {
 }
 
 // src/index.ts
-var import_datalog3 = require("@suss/datalog");
-var VALUE_STEP = (0, import_datalog3.constant)("value");
+var import_datalog4 = require("@suss/datalog");
+var VALUE_STEP = (0, import_datalog4.constant)("value");
 var NAMESPACE_IMPORT_NAME = "*";
-var NAMESPACE_IMPORT = (0, import_datalog3.constant)(NAMESPACE_IMPORT_NAME);
-var RESULT_STEP = (0, import_datalog3.constant)("result");
+var NAMESPACE_IMPORT = (0, import_datalog4.constant)(NAMESPACE_IMPORT_NAME);
+var RESULT_STEP = (0, import_datalog4.constant)("result");
 var RESOLUTION_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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), VALUE_STEP],
-    [(0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"))],
+    [(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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), VALUE_STEP],
-    [(0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"))],
+    [(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 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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("b"), VALUE_STEP],
-    [(0, import_datalog3.lit)("fallbackBranch", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("b"))],
+    [(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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("value"), VALUE_STEP],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("value"), VALUE_STEP],
     [
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value"))
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value"))
     ],
     "import"
   ),
   // A parameter steps to what a call passes it. A function called from
   // several places leaves its parameter with more than one value, and a
   // caller that needs those apart asks `paramAt`.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("a"), VALUE_STEP],
-    [(0, import_datalog3.lit)("passesArgument", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("a"))],
+    [(0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a"), VALUE_STEP],
+    [(0, import_datalog4.lit)("passesArgument", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a"))],
     "argument"
   ),
   // Reading a property steps to what the object contains under that
   // name, whichever way the object arrived: `routes.list` off a name,
   // or `make(body).handle` off a call.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("held"), VALUE_STEP],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("held"), VALUE_STEP],
     [
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("objectOf", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("obj")),
-      (0, import_datalog3.lit)("contains", (0, import_datalog3.variable)("obj"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held"))
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("x"), (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)("contains", (0, import_datalog4.variable)("obj"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
     ],
     "property read"
   ),
   // Calling a class makes one of it, so the call steps to the class and
   // 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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("cls"), VALUE_STEP],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cls"), VALUE_STEP],
     [
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("cls")),
-      (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("cls"))
+      (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")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("cls"))
     ],
     "class 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],
+    [
+      (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")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("cls")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      (0, import_datalog4.lit)("givesBackOne", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"))
+    ],
+    "declared finder"
+  ),
+  // The same word, for a library that takes the class as an argument
+  // 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],
+    [
+      (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")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a")),
+      // Before `libraryBase`, so the demand rewrite asks it with the base
+      // bound and walks an ancestry only for a method a pack declared.
+      (0, import_datalog4.lit)("givesBackOneOfArgument", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("cls")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"))
+    ],
+    "declared argument finder"
+  ),
+  // The same again for a function called on its own rather than read off
+  // 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],
+    [
+      (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)("givesBackOneOfImport", (0, import_datalog4.variable)("mod"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a")),
+      (0, import_datalog4.lit)("objectOf", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("cls"))
+    ],
+    "declared import finder"
+  ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("a"), VALUE_STEP],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("unwraps", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k")),
-      (0, import_datalog3.lit)("callArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("a"))
+      (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)("f")),
+      (0, import_datalog4.lit)("unwraps", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a"))
     ],
     "factory unwrap"
   ),
   // Wrapper transparency, declared: a pack says this callee wraps
   // 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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("a"), VALUE_STEP],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog3.lit)("calleeName", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("unwrapsByName", (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("k")),
-      (0, import_datalog3.lit)("wrapperModule", (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m")),
-      (0, import_datalog3.lit)("calleeOrigin", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("m")),
-      (0, import_datalog3.lit)("callArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("a"))
+      (0, import_datalog4.lit)("calleeName", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("unwrapsByName", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("wrapperModule", (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("calleeOrigin", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a"))
     ],
     "declared wrapper"
   ),
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "stepsTo",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("ret"), RESULT_STEP],
-    [(0, import_datalog3.lit)("invokes", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")), (0, import_datalog3.lit)("returnsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("ret"))],
+    [(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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "reaches",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), (0, import_datalog3.variable)("kind")],
-    [(0, import_datalog3.lit)("stepsTo", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), (0, import_datalog3.variable)("kind"))]
+    [(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"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "reaches",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), (0, import_datalog3.variable)("kind")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("kind")],
     [
-      (0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), VALUE_STEP),
-      (0, import_datalog3.lit)("stepsTo", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"), (0, import_datalog3.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"))
     ]
   ),
   // 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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "reaches",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), RESULT_STEP],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), RESULT_STEP),
-      (0, import_datalog3.lit)("stepsTo", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"), VALUE_STEP)
+      (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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "reaches",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), RESULT_STEP],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), RESULT_STEP),
-      (0, import_datalog3.lit)("stepsTo", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"), RESULT_STEP)
+      (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)
     ]
   ),
   // What a value comes down to: the walk that never ran a call, stopped
   // at a function or an object. Something already written out comes to
   // itself, and every other walk ends at one of those.
-  (0, import_datalog3.rule)("comesTo", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("func", (0, import_datalog3.variable)("x"))]),
-  (0, import_datalog3.rule)("comesTo", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("x"))]),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("comesTo", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("func", (0, import_datalog4.variable)("x"))]),
+  (0, import_datalog4.rule)("comesTo", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("x"))]),
+  (0, import_datalog4.rule)(
     "comesTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), VALUE_STEP), (0, import_datalog3.lit)("func", (0, import_datalog3.variable)("z"))]
+    [(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)("func", (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "comesTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), VALUE_STEP), (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("z"))]
+    [(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"))]
   ),
   // 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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "givesBack",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), RESULT_STEP), (0, import_datalog3.lit)("func", (0, import_datalog3.variable)("z"))]
+    [(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"), RESULT_STEP), (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "givesBack",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), RESULT_STEP), (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("z"))]
+    [(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"), RESULT_STEP), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("z"))]
   ),
   // Following a value to the expression it is written as, whatever kind
   // that is. A GraphQL document is neither a function nor an object, so
   // `comesTo` never reaches one.
-  (0, import_datalog3.rule)("isWrittenAs", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("writtenValue", (0, import_datalog3.variable)("x"))]),
-  (0, import_datalog3.rule)("isWrittenAs", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("x"))]),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("isWrittenAs", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("writtenValue", (0, import_datalog4.variable)("x"))]),
+  (0, import_datalog4.rule)("isWrittenAs", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("x"))]),
+  (0, import_datalog4.rule)(
     "isWrittenAs",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), VALUE_STEP), (0, import_datalog3.lit)("writtenValue", (0, import_datalog3.variable)("z"))]
+    [(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)("writtenValue", (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "isWrittenAs",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), VALUE_STEP), (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("z"))]
+    [(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"))]
   ),
   // A call is written as whatever its callee's return value is written
   // as. Unlike `comesTo`, this has nothing to protect: which expression
   // a value was written as does not compete with unwrapping it.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "isWrittenAs",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog3.lit)("invokes", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("returnsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("ret")),
-      (0, import_datalog3.lit)("isWrittenAs", (0, import_datalog3.variable)("ret"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("invokes", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("ret")),
+      (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("ret"), (0, import_datalog4.variable)("z"))
     ]
   ),
   // What one call site put in a parameter, told apart from what the
   // other callers passed.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "paramAt",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("z")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog3.lit)("passesArgument", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("a")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("a"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("passesArgument", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("z"))
     ]
   ),
   // An argument arriving at the parameter it is passed to, by position
   // or by the name the caller wrote, keeping the call it went through
   // so `paramAt` can tell two call sites apart.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passesArgument",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("a")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a")],
     [
-      (0, import_datalog3.lit)("paramOf", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("callsFunction", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("callArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("a"))
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("callsFunction", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passesArgument",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("a")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("a")],
     [
-      (0, import_datalog3.lit)("paramNamed", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("callsFunction", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("callKeywordArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("a"))
+      (0, import_datalog4.lit)("paramNamed", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("callsFunction", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("callKeywordArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("a"))
     ]
   ),
   // Which module's export a re-exported name forwards to, however
   // many barrels deep the forwarding runs.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "moduleForwards",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2")],
-    [(0, import_datalog3.lit)("reExports", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2"))]
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2")],
+    [(0, import_datalog4.lit)("reExports", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "moduleForwards",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m3"), (0, import_datalog3.variable)("n3")],
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m3"), (0, import_datalog4.variable)("n3")],
     [
-      (0, import_datalog3.lit)("reExports", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2")),
-      (0, import_datalog3.lit)("moduleForwards", (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2"), (0, import_datalog3.variable)("m3"), (0, import_datalog3.variable)("n3"))
+      (0, import_datalog4.lit)("reExports", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2")),
+      (0, import_datalog4.lit)("moduleForwards", (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2"), (0, import_datalog4.variable)("m3"), (0, import_datalog4.variable)("n3"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "moduleExport",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value")],
-    [(0, import_datalog3.lit)("exportsAs", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value"))],
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value")],
+    [(0, import_datalog4.lit)("exportsAs", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value"))],
     "export"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "moduleExport",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value")],
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value")],
     [
-      (0, import_datalog3.lit)("reExports", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2")),
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2"), (0, import_datalog3.variable)("value"))
+      (0, import_datalog4.lit)("reExports", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2")),
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2"), (0, import_datalog4.variable)("value"))
     ],
     "re-export"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "moduleExport",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value")],
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value")],
     [
-      (0, import_datalog3.lit)("reExportsAll", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("m2")),
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value"))
+      (0, import_datalog4.lit)("reExportsAll", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("m2")),
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value"))
     ],
     "re-export all"
   ),
   // The function a call runs, written from the call's side because a
   // caller asking what a call gives back has the call in hand.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "invokes",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")],
-    [(0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")), (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f"))]
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
+    [(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)("f"))]
   ),
   // The callee is itself a call: `daoBuilder()()`.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "invokes",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")],
-    [(0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")), (0, import_datalog3.lit)("givesBack", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f"))]
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("givesBack", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("f"))]
   ),
   // The object an expression refers to: a name through `comesTo`, a
   // factory call through what it gives back. Naming the step is what
   // makes `routes.list` and `make(body).handle` one rule.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "objectOf",
-    [(0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("obj")],
-    [(0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("obj")), (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("obj"))]
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("obj")],
+    [(0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("obj")), (0, import_datalog4.lit)("objectValue", (0, import_datalog4.variable)("obj"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "objectOf",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("obj")],
-    [(0, import_datalog3.lit)("givesBack", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("obj")), (0, import_datalog3.lit)("objectValue", (0, import_datalog3.variable)("obj"))]
+    [(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"))]
   ),
   // 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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callsFunction",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")],
-    [(0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f")), (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c"))]
+    [(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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callsFunction",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
     [
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c"))
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))
     ]
   ),
   // 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_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callsFunction",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("f")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("f")],
     [
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("d"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("d")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c"))
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("f")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("d"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("d")),
+      (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
@@ -992,47 +1416,73 @@ var RESOLUTION_RULES = [
   // declare gives two, and the caller decides. This is its own relation
   // rather than more `holdsProperty`, which stays something an adapter
   // states and the rules only read.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "contains",
-    [(0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held")],
-    [(0, import_datalog3.lit)("holdsProperty", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held"))]
+    [(0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
+    [(0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "contains",
-    [(0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held")],
+    [(0, import_datalog4.variable)("cls"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held")],
     [
-      (0, import_datalog3.lit)("extends", (0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("base")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("base"), (0, import_datalog3.variable)("baseCls")),
-      (0, import_datalog3.lit)("contains", (0, import_datalog3.variable)("baseCls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held"))
+      (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"))
+    ]
+  ),
+  // 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.
+  (0, import_datalog4.rule)("libraryBase", [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")], [(0, import_datalog4.lit)("extendsNamed", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n"))]),
+  (0, import_datalog4.rule)(
+    "libraryBase",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("libraryBase", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"))
+    ]
+  ),
+  // A base a library hands back from a call rather than exporting as a
+  // class, SQLAlchemy's `Base = declarative_base()`. The walk stops at
+  // the call, so the function it called is the name to match on.
+  (0, import_datalog4.rule)(
+    "libraryBase",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("cc")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("cc"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // Which function a factory returns, and which of its parameters that
   // function calls: together they are what makes it a wrapper.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "returnsFunc",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("g")],
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("g")],
     [
-      (0, import_datalog3.lit)("returnsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("value")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("value"), (0, import_datalog3.variable)("g")),
-      (0, import_datalog3.lit)("func", (0, import_datalog3.variable)("g"))
+      (0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("value")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("value"), (0, import_datalog4.variable)("g")),
+      (0, import_datalog4.lit)("func", (0, import_datalog4.variable)("g"))
     ]
   ),
   // A call made by a nested closure counts as made by the function
   // that declares it; the closure runs as part of that function.
-  (0, import_datalog3.rule)("bodyCallsDeep", [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("c")], [(0, import_datalog3.lit)("bodyCalls", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("c"))]),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("bodyCallsDeep", [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")], [(0, import_datalog4.lit)("bodyCalls", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c"))]),
+  (0, import_datalog4.rule)(
     "bodyCallsDeep",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("c")],
-    [(0, import_datalog3.lit)("containsFn", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("g")), (0, import_datalog3.lit)("bodyCallsDeep", (0, import_datalog3.variable)("g"), (0, import_datalog3.variable)("c"))]
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")],
+    [(0, import_datalog4.lit)("containsFn", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("g")), (0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("c"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "unwraps",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k")],
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k")],
     [
-      (0, import_datalog3.lit)("returnsFunc", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("g")),
-      (0, import_datalog3.lit)("bodyCallsDeep", (0, import_datalog3.variable)("g"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("paramOf", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("p"))
+      (0, import_datalog4.lit)("returnsFunc", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("g")),
+      (0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("p"))
     ]
   ),
   // Argument flow: which parameter a value traces back to. Directly
@@ -1040,297 +1490,297 @@ var RESOLUTION_RULES = [
   // another unwrapping factory. This is what lets
   // `createProtected(h) { return service.withAuth(h); }` unwrap:
   // the returned call passes h through withAuth, which unwraps.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "flowsToParam",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("paramOf", (0, import_datalog3.variable)("anyF"), (0, import_datalog3.variable)("anyK"), (0, import_datalog3.variable)("p"))
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("anyF"), (0, import_datalog4.variable)("anyK"), (0, import_datalog4.variable)("p"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "flowsToParam",
-    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f")),
-      (0, import_datalog3.lit)("unwraps", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k")),
-      (0, import_datalog3.lit)("callArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("a")),
-      (0, import_datalog3.lit)("flowsToParam", (0, import_datalog3.variable)("a"), (0, import_datalog3.variable)("p"))
+      (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)("f")),
+      (0, import_datalog4.lit)("unwraps", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k")),
+      (0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("a")),
+      (0, import_datalog4.lit)("flowsToParam", (0, import_datalog4.variable)("a"), (0, import_datalog4.variable)("p"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "unwraps",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k")],
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k")],
     [
-      (0, import_datalog3.lit)("returnsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("value")),
-      (0, import_datalog3.lit)("flowsToParam", (0, import_datalog3.variable)("value"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("paramOf", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("p"))
+      (0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("value")),
+      (0, import_datalog4.lit)("flowsToParam", (0, import_datalog4.variable)("value"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("paramOf", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("p"))
     ]
   ),
   // 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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "comesFrom",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
-    [(0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
+    [(0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "comesFrom",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("reaches", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), VALUE_STEP),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("reaches", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), VALUE_STEP),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // 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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callsInto",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("bodyCallsDeep", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesFrom", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callsInto",
-    [(0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("bodyCallsDeep", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("g")),
-      (0, import_datalog3.lit)("callsInto", (0, import_datalog3.variable)("g"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("bodyCallsDeep", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("c")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("g")),
+      (0, import_datalog4.lit)("callsInto", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // The question callers ask: what a value comes to, narrowed to the
   // functions. Objects appear in the middle of chains and never in an
   // answer.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "resolves",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")), (0, import_datalog3.lit)("func", (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(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"))]
   )
 ];
 var RESOLUTION_QUESTIONS = [
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedResolves",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("resolves", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("resolves", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedComesTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedComesTo",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wantedOrigin", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("wantedOrigin", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedIsWrittenAs",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("isWrittenAs", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(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.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedObjectOf",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("objectOf", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(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"))]
   ),
   // The same for the function a call returns: `app.use(requireCaller(config))`
   // registers what the factory gives back, and `resolves` on the call
   // says nothing unless the factory unwraps an argument.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedGivesBack",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("givesBack", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("wanted", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("givesBack", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
   ),
   // Keyed by the parameter, since that is what a caller has in hand
   // when it wants the call sites told apart.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedParamAt",
-    [(0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("p")), (0, import_datalog3.lit)("paramAt", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("z"))]
+    [(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"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedComesFrom",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
-    [(0, import_datalog3.lit)("wantedOrigin", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("comesFrom", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
+    [(0, import_datalog4.lit)("wantedOrigin", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("comesFrom", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))]
   ),
   // Call-origin questions, for attribution, in their own demand
   // class. Attribution stops at the import declaration, so nothing
   // here demands reaches or callsInto. The chains are closures with
   // no depth bound: an alias run of any length resolves.
-  (0, import_datalog3.rule)("callOriginChain", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("wantedCallOrigin", (0, import_datalog3.variable)("x"))]),
+  (0, import_datalog4.rule)("callOriginChain", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("wantedCallOrigin", (0, import_datalog4.variable)("x"))]),
   // The chain with at least one hop taken, which is what tells a
   // destructured binding apart from asking about a node directly. The
   // whole chain is the seed plus those hops.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callOriginChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("callOriginChainStepped", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("callOriginChainStepped", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callOriginChainStepped",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callOriginChainStepped",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callOriginChainStepped",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("fallbackBranch", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("fallbackBranch", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // An import of a project barrel is an import of what the barrel
   // forwards, so the pair surfaces the module behind the chain.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2")],
     [
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("moduleForwards", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m2"), (0, import_datalog3.variable)("n2"))
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("moduleForwards", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("m2"), (0, import_datalog4.variable)("n2"))
     ]
   ),
   // A namespace member: the module's export of the member's own name.
   // The imports literal leads, since it is the smallest relation.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("m"), NAMESPACE_IMPORT),
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"))
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("d"), (0, import_datalog3.variable)("m"), NAMESPACE_IMPORT),
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("d")),
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"))
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("d"), (0, import_datalog4.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("d")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"))
     ]
   ),
   // What a call made: through the call to its callee, whose own alias
   // chain leads to the import.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMadeChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("f")],
-    [(0, import_datalog3.lit)("callOriginChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("c")), (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("callOriginChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("f"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMadeChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("callMadeChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("callMadeChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMadeChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("callMadeChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("callMadeChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("callMadeChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("callMadeChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // A member destructured off what a call made keeps the member name
   // as one more path segment.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMemberChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("callOriginChainStepped", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("e")),
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("f"))
+      (0, import_datalog4.lit)("callOriginChainStepped", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("e")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("e"), (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("f"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMemberChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("callMemberChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("callMemberChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "callMemberChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("callMemberChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("callMemberChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallOriginMember",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("p")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("p")],
     [
-      (0, import_datalog3.lit)("callMemberChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("p")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("callMemberChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("p")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCallsInto",
-    [(0, import_datalog3.variable)("g"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("wantedOrigin", (0, import_datalog3.variable)("x")),
-      (0, import_datalog3.lit)("comesTo", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("g")),
-      (0, import_datalog3.lit)("callsInto", (0, import_datalog3.variable)("g"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("wantedOrigin", (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("comesTo", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("g")),
+      (0, import_datalog4.lit)("callsInto", (0, import_datalog4.variable)("g"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // Subject identity, its own demand class; the README's subject
   // section says why the origin pair rides on the written-value walk.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedSubjectWritten",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r")],
-    [(0, import_datalog3.lit)("wantedSubject", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("isWrittenAs", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")],
+    [(0, import_datalog4.lit)("wantedSubject", (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedSubjectConstruction",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)("wantedSubject", (0, import_datalog3.variable)("x")),
-      (0, import_datalog3.lit)("isWrittenAs", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
-      (0, import_datalog3.lit)("comesFrom", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("wantedSubject", (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("isWrittenAs", (0, import_datalog4.variable)("x"), (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)("m"), (0, import_datalog4.variable)("n"))
     ]
   ),
   // The export table of one module, keyed by the module asked about.
   // The moduleExport rules flatten re-export chains of any length, and
   // the demand cone stays on export facts alone.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedModuleExport",
-    [(0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value")],
+    [(0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value")],
     [
-      (0, import_datalog3.lit)("wantedExportsOf", (0, import_datalog3.variable)("m")),
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("value"))
+      (0, import_datalog4.lit)("wantedExportsOf", (0, import_datalog4.variable)("m")),
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("value"))
     ]
   ),
   // The calls behind a receiver, for a pack that wants the anchor a
@@ -1339,63 +1789,74 @@ var RESOLUTION_QUESTIONS = [
   // A class's ancestry, one hop per extends through the binding that
   // says which class the written base is; the names on the way out
   // are what a storage pack matches its library's bases against.
-  (0, import_datalog3.rule)("ancestryChain", [(0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("c")], [(0, import_datalog3.lit)("wantedAncestry", (0, import_datalog3.variable)("c"))]),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("ancestryChain", [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("c")], [(0, import_datalog4.lit)("wantedAncestry", (0, import_datalog4.variable)("c"))]),
+  (0, import_datalog4.rule)(
     "ancestryChain",
-    [(0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("b2")],
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b2")],
     [
-      (0, import_datalog3.lit)("ancestryChain", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("b")),
-      (0, import_datalog3.lit)("extends", (0, import_datalog3.variable)("b"), (0, import_datalog3.variable)("x")),
-      (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("b2"))
+      (0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("extends", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("b2"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedBaseName",
-    [(0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("n")],
-    [(0, import_datalog3.lit)("ancestryChain", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("b")), (0, import_datalog3.lit)("extendsNamed", (0, import_datalog3.variable)("b"), (0, import_datalog3.variable)("n"))]
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [(0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")), (0, import_datalog4.lit)("extendsNamed", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"))]
+  ),
+  // Each method the same chain declares, so a caller that settled a
+  // receiver on a class can tell a method the project writes itself
+  // from one only the library provides.
+  (0, import_datalog4.rule)(
+    "wantedDeclaredName",
+    [(0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("n")],
+    [
+      (0, import_datalog4.lit)("ancestryChain", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("b")),
+      (0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("b"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("held"))
+    ]
   ),
-  (0, import_datalog3.rule)("anchorChain", [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("wantedAnchor", (0, import_datalog3.variable)("x"))]),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("anchorChain", [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("wantedAnchor", (0, import_datalog4.variable)("x"))]),
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
-    [(0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")), (0, import_datalog3.lit)("fallbackBranch", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("z"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
+    [(0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")), (0, import_datalog4.lit)("fallbackBranch", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("z"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("z")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("z")],
     [
-      (0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("imports", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("moduleExport", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("z"))
+      (0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("imports", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("moduleExport", (0, import_datalog4.variable)("m"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("z"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("c")],
-    [(0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r")), (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("c")],
+    [(0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "anchorChain",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("o")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("o")],
     [
-      (0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n"))
+      (0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("y")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n"))
     ]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedAnchorCall",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r")],
-    [(0, import_datalog3.lit)("anchorChain", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("r")), (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c"))]
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")],
+    [(0, import_datalog4.lit)("anchorChain", (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("r")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("c"))]
   )
 ];
 var ANSWER_RELATIONS = [
@@ -1404,6 +1865,7 @@ var ANSWER_RELATIONS = [
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANSWER_RELATIONS,
+  ASKING_RELATIONS,
   FACT_CONTRACT_CASES,
   NAMESPACE_IMPORT,
   NAMESPACE_IMPORT_NAME,
@@ -1412,14 +1874,24 @@ var ANSWER_RELATIONS = [
   RESULT_STEP,
   VALUE_STEP,
   agreedMountPrefix,
+  askResolution,
+  calleeOutcomeOf,
+  calleeOutcomes,
   checkFactContract,
+  couldBeSettled,
   explainResolutionProof,
   explainResolvedKey,
   joinMountedPath,
   mountPathsOf,
   nodeOfKey,
   placeholderValues,
+  queryFacts,
   renderExplanation,
+  resolutionProgram,
   singleAnswers,
+  startsAtName,
+  valueLeftByWrites,
+  writesRunInOrder,
+  writtenSourcesOf,
   writtenValueOf
 });