@suss/resolution 0.35.0 → 0.36.0

package/dist/index.cjs

@@ -42,6 +42,10 @@ __export(index_exports, {
   RESOLUTION_QUESTIONS: () => RESOLUTION_QUESTIONS,
   RESOLUTION_RULES: () => RESOLUTION_RULES,
   RESULT_STEP: () => RESULT_STEP,
+  SELF_AS_CLASS: () => SELF_AS_CLASS,
+  SELF_AS_CLASS_NAME: () => SELF_AS_CLASS_NAME,
+  SELF_AS_INSTANCE: () => SELF_AS_INSTANCE,
+  SELF_AS_INSTANCE_NAME: () => SELF_AS_INSTANCE_NAME,
   SPREAD_ENTRY: () => SPREAD_ENTRY,
   UNDER_ANSWER_RELATIONS: () => UNDER_ANSWER_RELATIONS,
   UNDER_QUESTION_ROW_BUDGET: () => UNDER_QUESTION_ROW_BUDGET,
@@ -81,6 +85,8 @@ __export(index_exports, {
   isObserved: () => isObserved,
   isWrittenAsUnder: () => isWrittenAsUnder,
   joinMountedPath: () => joinMountedPath,
+  keptVariants: () => keptVariants,
+  memberOf: () => memberOf,
   mergeStoredDependencies: () => mergeStoredDependencies,
   mountPathsOf: () => mountPathsOf,
   noDependencies: () => noDependencies,
@@ -90,6 +96,7 @@ __export(index_exports, {
   objectOfUnder: () => objectOfUnder,
   observeDemand: () => observeDemand,
   packHashes: () => packHashes,
+  plainKeyOf: () => plainKeyOf,
   proofRules: () => proofRules,
   queryFacts: () => queryFacts,
   readDispatchOutcomes: () => readDispatchOutcomes,
@@ -99,6 +106,8 @@ __export(index_exports, {
   resolutionProgram: () => resolutionProgram,
   resolutionUnderProgram: () => resolutionUnderProgram,
   resolvedFunctions: () => resolvedFunctions,
+  selfFormOf: () => selfFormOf,
+  selfResultOf: () => selfResultOf,
   settledFunction: () => settledFunction,
   sourceLeavesOf: () => sourceLeavesOf,
   spanOfKey: () => spanOfKey,
@@ -108,6 +117,7 @@ __export(index_exports, {
   underQuestionSpend: () => underQuestionSpend,
   unpackHashes: () => unpackHashes,
   valueLeftByWrites: () => valueLeftByWrites,
+  variantKey: () => variantKey,
   walkRecordsByFile: () => walkRecordsByFile,
   writesRunInOrder: () => writesRunInOrder,
   writtenAnswersFor: () => writtenAnswersFor,
@@ -139,7 +149,8 @@ var ASKING_RELATIONS = [
   "wantedType",
   "wantedUses",
   "wantedSource",
-  "wantedInputRead"
+  "wantedInputRead",
+  "wantedMembers"
 ];
 var NO_LANGUAGE_RULES = [];
 var programs = /* @__PURE__ */ new WeakMap();
@@ -2064,6 +2075,155 @@ function importedFilesByFile(db, displayPathOf) {
   return byFile;
 }
 
+// src/receiverSelf.ts
+var import_datalog3 = require("@suss/datalog");
+var MEMBERS_QUESTION = "wantedMembers";
+var SELF_AS_CLASS_NAME = "class";
+var SELF_AS_CLASS = (0, import_datalog3.constant)(SELF_AS_CLASS_NAME);
+var SELF_AS_INSTANCE_NAME = "instance";
+var SELF_AS_INSTANCE = (0, import_datalog3.constant)(SELF_AS_INSTANCE_NAME);
+var SELF_RULES = [
+  (0, import_datalog3.rule)(
+    "selfBehind",
+    [(0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form")],
+    [(0, import_datalog3.lit)("selfReceiver", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form"))],
+    "the receiver"
+  ),
+  // `klass = self` or `job = new(...)`. Only names, so a receiver passed
+  // into another method is that method's parameter and never its own.
+  (0, import_datalog3.rule)(
+    "selfBehind",
+    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form")],
+    [
+      (0, import_datalog3.lit)("nameHop", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
+      (0, import_datalog3.lit)("selfBehind", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form"))
+    ],
+    "a name for the receiver"
+  ),
+  // Calling the class makes one of it: Python's `cls(...)` and
+  // TypeScript's `new this(...)`.
+  (0, import_datalog3.rule)(
+    "selfBehind",
+    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("s"), SELF_AS_INSTANCE],
+    [
+      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
+      (0, import_datalog3.lit)("selfBehind", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("s"), SELF_AS_CLASS)
+    ],
+    "made from the receiver's class"
+  ),
+  // A method that returns its receiver, or one made from it, returns the
+  // caller's: `Report.build(x)` is a Report when `build` is
+  // `def self.build(x) = new(x)`, whichever class `build` is written in.
+  (0, import_datalog3.rule)(
+    "selfResult",
+    [(0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("form")],
+    [
+      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("c")),
+      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n")),
+      (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_datalog3.lit)("selfReceiver", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("any")),
+      (0, import_datalog3.lit)("selfBehind", (0, import_datalog3.variable)("ret"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form"))
+    ],
+    "returns its receiver"
+  ),
+  (0, import_datalog3.rule)(
+    "selfResult",
+    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("form")],
+    [
+      (0, import_datalog3.lit)("nameHop", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("y")),
+      (0, import_datalog3.lit)("selfResult", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("form"))
+    ],
+    "a name for what it returned"
+  )
+];
+var SELF_QUESTIONS = [
+  (0, import_datalog3.rule)(
+    "wantedSelfBehind",
+    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form")],
+    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("selfBehind", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("s"), (0, import_datalog3.variable)("form"))]
+  ),
+  (0, import_datalog3.rule)(
+    "wantedSelfResult",
+    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("form")],
+    [(0, import_datalog3.lit)("wanted", (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("selfResult", (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("form"))]
+  ),
+  // Every member a class has, its bases' included, and the ones a nearer
+  // member overrides, for a walk that looks a method up on a subclass.
+  (0, import_datalog3.rule)(
+    "wantedMemberOf",
+    [(0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held")],
+    [
+      (0, import_datalog3.lit)(MEMBERS_QUESTION, (0, import_datalog3.variable)("cls")),
+      (0, import_datalog3.lit)("contains", (0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("held"))
+    ]
+  ),
+  (0, import_datalog3.rule)(
+    "wantedMemberOverridden",
+    [(0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("h")],
+    [
+      (0, import_datalog3.lit)(MEMBERS_QUESTION, (0, import_datalog3.variable)("cls")),
+      (0, import_datalog3.lit)("contains", (0, import_datalog3.variable)("cls"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("m")),
+      (0, import_datalog3.lit)("overrides", (0, import_datalog3.variable)("m"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("h"))
+    ]
+  )
+];
+function selfResultOf(db, key) {
+  const rows = db.lookup("wantedSelfResult", 0, key);
+  const [only] = rows;
+  return rows.length === 1 && only !== void 0 ? { receiver: String(only[1]), form: String(only[2]) } : null;
+}
+function selfFormOf(db, key, receiver) {
+  const forms = new Set(
+    db.lookup("wantedSelfBehind", 0, key).filter((row) => String(row[1]) === receiver).map((row) => String(row[2]))
+  );
+  const [only] = forms;
+  return forms.size === 1 && only !== void 0 ? only : null;
+}
+var ON_SUBCLASS = "#on=";
+function variantKey(key, subclass) {
+  return `${key}${ON_SUBCLASS}${encodeURIComponent(subclass.name)}@${encodeURIComponent(subclass.file)}`;
+}
+function plainKeyOf(key) {
+  const at = key.indexOf(ON_SUBCLASS);
+  return at === -1 ? key : key.slice(0, at);
+}
+function keptVariants(variants) {
+  const callers = /* @__PURE__ */ new Map();
+  for (const variant of variants) {
+    for (const callee of variant.calls) {
+      const known = callers.get(callee) ?? [];
+      known.push(variant.key);
+      callers.set(callee, known);
+    }
+  }
+  const kept = /* @__PURE__ */ new Set();
+  const queue = variants.filter((variant) => variant.differs).map((variant) => variant.key);
+  for (let key = queue.pop(); key !== void 0; key = queue.pop()) {
+    if (kept.has(key)) {
+      continue;
+    }
+    kept.add(key);
+    queue.push(...callers.get(key) ?? []);
+  }
+  return kept;
+}
+
+// src/members.ts
+function memberOf(db, classKey, name, program) {
+  askResolution(db, [classKey], MEMBERS_QUESTION, program);
+  const overridden = new Set(
+    db.lookup("wantedMemberOverridden", 0, classKey).filter((row) => String(row[1]) === name).map((row) => String(row[2]))
+  );
+  const found = [
+    ...new Set(
+      db.lookup("wantedMemberOf", 0, classKey).filter((row) => String(row[1]) === name).map((row) => String(row[2])).filter((held) => !overridden.has(held))
+    )
+  ];
+  const [only] = found;
+  return found.length === 1 && only !== void 0 ? only : null;
+}
+
 // src/mount.ts
 function joinMountedPath(prefix, path) {
   const trimmed = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
@@ -2233,132 +2393,132 @@ function addPackWords(db, words) {
 }
 
 // src/passedOn.ts
-var import_datalog3 = require("@suss/datalog");
+var import_datalog4 = require("@suss/datalog");
 var USES_QUESTION = "wantedUses";
 var PASSED_ON_RULES = [
-  (0, import_datalog3.rule)("passedOn", [(0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("returnsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("x"))], "returned"),
-  (0, import_datalog3.rule)("passedOn", [(0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("yieldsValue", (0, import_datalog3.variable)("f"), (0, import_datalog3.variable)("x"))], "yielded"),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("passedOn", [(0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("returnsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("x"))], "returned"),
+  (0, import_datalog4.rule)("passedOn", [(0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("yieldsValue", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("x"))], "yielded"),
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("callArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("callArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("x"))],
     "an argument"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("callKeywordArg", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("k"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("callKeywordArg", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("k"), (0, import_datalog4.variable)("x"))],
     "a keyword argument"
   ),
-  (0, import_datalog3.rule)("passedOn", [(0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("binds", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("x"))], "another name"),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("passedOn", [(0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("binds", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("x"))], "another name"),
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("endsHolding", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("endsHolding", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("x"))],
     "another name's last write"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("mayHold", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("mayHold", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("x"))],
     "one of another name's writes"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("holdsProperty", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("holdsProperty", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("x"))],
     "held by an object"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("storesProperty", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("n"), (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("k"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("storesProperty", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("n"), (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("k"))],
     "stored on an object"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("holdsUnderKey", (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("holdsUnderKey", (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("x"))],
     "stored under a key"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("readsKeyed", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("o"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("readsKeyed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("o"), (0, import_datalog4.variable)("x"))],
     "used as a key"
   ),
-  (0, import_datalog3.rule)("passedOn", [(0, import_datalog3.variable)("x")], [(0, import_datalog3.lit)("entersValue", (0, import_datalog3.variable)("x"))], "entered"),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)("passedOn", [(0, import_datalog4.variable)("x")], [(0, import_datalog4.lit)("entersValue", (0, import_datalog4.variable)("x"))], "entered"),
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("entersAs", (0, import_datalog3.variable)("y"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("entersAs", (0, import_datalog4.variable)("y"), (0, import_datalog4.variable)("x"))],
     "entered under a name"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("paramDefault", (0, import_datalog3.variable)("p"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("paramDefault", (0, import_datalog4.variable)("p"), (0, import_datalog4.variable)("x"))],
     "a parameter default"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("fallbackBranch", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("fallbackBranch", (0, import_datalog4.variable)("e"), (0, import_datalog4.variable)("x"))],
     "a fallback branch"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("conditionalBranch", (0, import_datalog3.variable)("e"), (0, import_datalog3.variable)("x"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("conditionalBranch", (0, import_datalog4.variable)("e"), (0, import_datalog4.variable)("x"))],
     "a conditional branch"
   ),
   // `app.router` and `app[key]` hand out a part of the value, so the value
   // goes wherever that part goes. This rule skips a part called at once,
   // `app.run()`, which `wantedCalledMethod` lists instead.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("n")), (0, import_datalog3.lit)("passedOn", (0, import_datalog3.variable)("r"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("n")), (0, import_datalog4.lit)("passedOn", (0, import_datalog4.variable)("r"))],
     "a property passed on"
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)("readsKeyed", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("k")), (0, import_datalog3.lit)("passedOn", (0, import_datalog3.variable)("r"))],
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)("readsKeyed", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("k")), (0, import_datalog4.lit)("passedOn", (0, import_datalog4.variable)("r"))],
     "an entry passed on"
   ),
   // A method's result can be the value itself, as a builder's is, or
   // carry what was registered on it, as `s.router(contract, handlers)`
   // does, so passing the result on passes the value on.
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "passedOn",
-    [(0, import_datalog3.variable)("x")],
+    [(0, import_datalog4.variable)("x")],
     [
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("r")),
-      (0, import_datalog3.lit)("passedOn", (0, import_datalog3.variable)("c"))
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("r")),
+      (0, import_datalog4.lit)("passedOn", (0, import_datalog4.variable)("c"))
     ],
     "a method result passed on"
   )
 ];
 var USES_QUESTIONS = [
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedPassedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)(USES_QUESTION, (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("passedOn", (0, import_datalog3.variable)("x"))]
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)(USES_QUESTION, (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("passedOn", (0, import_datalog4.variable)("x"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedPassedOn",
-    [(0, import_datalog3.variable)("x")],
-    [(0, import_datalog3.lit)(USES_QUESTION, (0, import_datalog3.variable)("x")), (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("x"))]
+    [(0, import_datalog4.variable)("x")],
+    [(0, import_datalog4.lit)(USES_QUESTION, (0, import_datalog4.variable)("x")), (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("x"))]
   ),
-  (0, import_datalog3.rule)(
+  (0, import_datalog4.rule)(
     "wantedCalledMethod",
-    [(0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("n")],
+    [(0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("n")],
     [
-      (0, import_datalog3.lit)(USES_QUESTION, (0, import_datalog3.variable)("x")),
-      (0, import_datalog3.lit)("readsProperty", (0, import_datalog3.variable)("r"), (0, import_datalog3.variable)("x"), (0, import_datalog3.variable)("n")),
-      (0, import_datalog3.lit)("call", (0, import_datalog3.variable)("c"), (0, import_datalog3.variable)("r"))
+      (0, import_datalog4.lit)(USES_QUESTION, (0, import_datalog4.variable)("x")),
+      (0, import_datalog4.lit)("readsProperty", (0, import_datalog4.variable)("r"), (0, import_datalog4.variable)("x"), (0, import_datalog4.variable)("n")),
+      (0, import_datalog4.lit)("call", (0, import_datalog4.variable)("c"), (0, import_datalog4.variable)("r"))
     ]
   )
 ];
@@ -2377,13 +2537,13 @@ function staysInItsFunction(uses, ownMethods) {
 }
 
 // src/session.ts
-var import_datalog4 = require("@suss/datalog");
+var import_datalog5 = require("@suss/datalog");
 var PROOF_OVERRIDES = {
   overridden: "readsOverridden",
   found: "readsMemberOn"
 };
 function proofRules(rules) {
-  return (0, import_datalog4.rulesDeriving)(rules, [
+  return (0, import_datalog5.rulesDeriving)(rules, [
     "resolves",
     PROOF_OVERRIDES.overridden,
     PROOF_OVERRIDES.found
@@ -2393,7 +2553,7 @@ function explainResolvedKey(options) {
   const { db, rules, key, locate, displayPath } = options;
   const witnessRules = proofRules(rules);
   const started = performance.now();
-  (0, import_datalog4.evaluate)(db, witnessRules, import_datalog4.witnesses);
+  (0, import_datalog5.evaluate)(db, witnessRules, import_datalog5.witnesses);
   const evaluateMs = performance.now() - started;
   const { baseFacts, derivedFacts } = factCounts(db, witnessRules);
   const targets = answersFor(db, "resolves", key, PROOF_OVERRIDES);
@@ -2401,7 +2561,7 @@ function explainResolvedKey(options) {
     return null;
   }
   const target = targets[0];
-  const proof = (0, import_datalog4.proofOf)(
+  const proof = (0, import_datalog5.proofOf)(
     db,
     "resolves",
     [key, target],
@@ -2714,30 +2874,30 @@ function sharedConstruction(writes) {
 }
 
 // src/index.ts
-var import_datalog5 = require("@suss/datalog");
-var VALUE_STEP = (0, import_datalog5.constant)("value");
+var import_datalog6 = require("@suss/datalog");
+var VALUE_STEP = (0, import_datalog6.constant)("value");
 var NAMESPACE_IMPORT_NAME = "*";
-var NAMESPACE_IMPORT = (0, import_datalog5.constant)(NAMESPACE_IMPORT_NAME);
+var NAMESPACE_IMPORT = (0, import_datalog6.constant)(NAMESPACE_IMPORT_NAME);
 var DEFAULT_IMPORT_NAME = "default";
-var DEFAULT_IMPORT = (0, import_datalog5.constant)(DEFAULT_IMPORT_NAME);
+var DEFAULT_IMPORT = (0, import_datalog6.constant)(DEFAULT_IMPORT_NAME);
 var GLOBAL_MODULE = "global";
 var NAMESPACE_MEMBER_RULE = "namespace member";
 var BASE_CLASS_RULE = "base class";
 var NAME_HOP_RULE = "name hop";
-var INSTANCE_STEP = (0, import_datalog5.constant)("instance");
+var INSTANCE_STEP = (0, import_datalog6.constant)("instance");
 var RECEIVER_STORE_NAME = "receiver";
-var RECEIVER_STORE = (0, import_datalog5.constant)(RECEIVER_STORE_NAME);
+var RECEIVER_STORE = (0, import_datalog6.constant)(RECEIVER_STORE_NAME);
 var NAMED_STORE_NAME = "name";
-var NAMED_STORE = (0, import_datalog5.constant)(NAMED_STORE_NAME);
+var NAMED_STORE = (0, import_datalog6.constant)(NAMED_STORE_NAME);
 var UNPLACED_STORE_NAME = "unplaced";
-var NO_ARGUMENTS = (0, import_datalog5.constant)("0");
-var FIRST_POSITION = (0, import_datalog5.constant)("0");
-var THEN_METHOD = (0, import_datalog5.constant)("then");
-var RESULT_STEP = (0, import_datalog5.constant)("result");
+var NO_ARGUMENTS = (0, import_datalog6.constant)("0");
+var FIRST_POSITION = (0, import_datalog6.constant)("0");
+var THEN_METHOD = (0, import_datalog6.constant)("then");
+var RESULT_STEP = (0, import_datalog6.constant)("result");
 var NO_CONTEXT_NAME = "none";
-var NO_CONTEXT = (0, import_datalog5.constant)(NO_CONTEXT_NAME);
+var NO_CONTEXT = (0, import_datalog6.constant)(NO_CONTEXT_NAME);
 var STEP_LATTICE = [
-  { soFar: VALUE_STEP, next: (0, import_datalog5.variable)("kind"), took: (0, import_datalog5.variable)("kind") },
+  { soFar: VALUE_STEP, next: (0, import_datalog6.variable)("kind"), took: (0, import_datalog6.variable)("kind") },
   { soFar: INSTANCE_STEP, next: VALUE_STEP, took: INSTANCE_STEP },
   { soFar: INSTANCE_STEP, next: INSTANCE_STEP, took: INSTANCE_STEP },
   { soFar: INSTANCE_STEP, next: RESULT_STEP, took: RESULT_STEP },
@@ -2746,1191 +2906,1191 @@ var STEP_LATTICE = [
   { soFar: RESULT_STEP, next: RESULT_STEP, took: RESULT_STEP }
 ];
 var DISPATCH_RULES = [
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entryRead",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o")],
-    [(0, import_datalog5.lit)("choosesEntry", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o")],
+    [(0, import_datalog6.lit)("choosesEntry", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entryRead",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o")],
-    [(0, import_datalog5.lit)("namedEntryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o")],
+    [(0, import_datalog6.lit)("namedEntryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entryRead",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o")],
-    [(0, import_datalog5.lit)("choosesEntryLike", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("s"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o")],
+    [(0, import_datalog6.lit)("choosesEntryLike", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("s"))]
   ),
   // Every entry of a read whose key is partly written out, by name. A rule
   // cannot compare strings, so dispatch.ts keeps the names that match, and
   // these stay out of `dispatchesTo`.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "likeEntryAt",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("choosesEntryLike", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("s")),
-      (0, import_datalog5.lit)("containerOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("choosesEntryLike", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("s")),
+      (0, import_datalog6.lit)("containerOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "namedEntryRead",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("choosesNamedEntry", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("choosesNamedEntry", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "namedEntryRead",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("readsEntry", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("readsEntry", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"))]
   ),
   // The container a read takes its entry from: an object written out, or
   // a collection the program fills through its methods.
-  (0, import_datalog5.rule)("containerOf", [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")], [(0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("containerOf", [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")], [(0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj"))]),
+  (0, import_datalog6.rule)(
     "containerOf",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), VALUE_STEP),
-      (0, import_datalog5.lit)("collectionValue", (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), VALUE_STEP),
+      (0, import_datalog6.lit)("collectionValue", (0, import_datalog6.variable)("c"))
     ]
   ),
-  (0, import_datalog5.rule)("containerOf", [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c")], [(0, import_datalog5.lit)("collectionValue", (0, import_datalog5.variable)("c"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("containerOf", [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c")], [(0, import_datalog6.lit)("collectionValue", (0, import_datalog6.variable)("c"))]),
+  (0, import_datalog6.rule)(
     "entryAt",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("choosesEntry", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("containerOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("choosesEntry", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("containerOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "any entry"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entryAt",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("namedEntryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("containerOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("namedEntryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("containerOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "named entry"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entryAt",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")],
-    [(0, import_datalog5.lit)("computedEntryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")],
+    [(0, import_datalog6.lit)("computedEntryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held"))]
   ),
   // A write under a key the source computes, `T[name] = fn` or a map's
   // `set`, could be under any name, so every read of the container may
   // come back with it, a read narrowed to one name included.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "computedEntryAt",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("entryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("containerOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("holdsUnderKey", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("entryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("containerOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("holdsUnderKey", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("held"))
     ],
     "entry under a computed key"
   ),
   // The read a call takes its function from: the callee itself, a name
   // for it, or the call when the call is the read, as Ruby's `send` is.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsEntryAt",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")), (0, import_datalog5.lit)("entryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")), (0, import_datalog6.lit)("entryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsEntryAt",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site"), VALUE_STEP),
-      (0, import_datalog5.lit)("entryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site"), VALUE_STEP),
+      (0, import_datalog6.lit)("entryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"))
     ]
   ),
-  (0, import_datalog5.rule)("callsEntryAt", [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("r")], [(0, import_datalog5.lit)("callsChosenEntry", (0, import_datalog5.variable)("r"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("callsEntryAt", [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("r")], [(0, import_datalog6.lit)("callsChosenEntry", (0, import_datalog6.variable)("r"))]),
+  (0, import_datalog6.rule)(
     "callsEntryAt",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("callsEntryInBranch", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("callsEntryInBranch", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site"))]
   ),
   // `c ? T[k] : undefined` is one of its branches, so a call through it
   // may run what the read gives. The other branch may be some other
   // function, so dispatch.ts never counts such a call as certain.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsEntryInBranch",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("branchReadsEntry", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("branchReadsEntry", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsEntryInBranch",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x"), VALUE_STEP),
-      (0, import_datalog5.lit)("branchReadsEntry", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("site"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x"), VALUE_STEP),
+      (0, import_datalog6.lit)("branchReadsEntry", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("site"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "branchReadsEntry",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("conditionalBranch", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("entryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"))
+      (0, import_datalog6.lit)("conditionalBranch", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("entryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "branchReadsEntry",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("conditionalBranch", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("site"), VALUE_STEP),
-      (0, import_datalog5.lit)("entryRead", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"))
+      (0, import_datalog6.lit)("conditionalBranch", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("site"), VALUE_STEP),
+      (0, import_datalog6.lit)("entryRead", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "dispatchesTo",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("entryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("entryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("f"))
     ]
   ),
   // A collection a program fills is an object the way a written one is,
   // so a write through a name for it lands on it.
-  (0, import_datalog5.rule)("refersToObject", [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c")], [(0, import_datalog5.lit)("collectionValue", (0, import_datalog5.variable)("c"))])
+  (0, import_datalog6.rule)("refersToObject", [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c")], [(0, import_datalog6.lit)("collectionValue", (0, import_datalog6.variable)("c"))])
 ];
 var STATED_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
   // Every chain that follows a name takes the name hops, so a hop added
   // here reaches all of them.
-  (0, import_datalog5.rule)("nameHop", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")], [(0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))], "alias"),
+  (0, import_datalog6.rule)("nameHop", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")], [(0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("x"), (0, import_datalog6.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; the rule below takes that name instead.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "nameHop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")],
-    [(0, import_datalog5.lit)("endsHolding", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")],
+    [(0, import_datalog6.lit)("endsHolding", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))],
     "last write"
   ),
   // A name whose writes nothing orders leads to each of them, so a
   // caller that can use several values gets them all and one that needs
   // a single value gets none. A write stating no value stops every step.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "nameHop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")],
-    [(0, import_datalog5.lit)("mayHold", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("writesAllStated", (0, import_datalog5.variable)("x"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")],
+    [(0, import_datalog6.lit)("mayHold", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("writesAllStated", (0, import_datalog6.variable)("x"))],
     "one of several writes"
   ),
   // A fallback says the value is one of its branches, so each branch is
   // a step. A branch that resolves to nothing makes no claim, and two
   // branches resolving to different things fail the single-answer policy.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "nameHop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b")],
-    [(0, import_datalog5.lit)("fallbackBranch", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b")],
+    [(0, import_datalog6.lit)("fallbackBranch", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b"))],
     "fallback"
   ),
   // Every name hop is a value step. A language with a hop of its own, like
   // Ruby's `Const.new`, states it as a step too, or every question but
   // `comesTo` misses it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), VALUE_STEP],
-    [(0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), VALUE_STEP],
+    [(0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))],
     NAME_HOP_RULE
   ),
   // An import steps to what the module exports under that name. It is
   // not a name hop, because the call-origin chains stop at the import.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("value"), VALUE_STEP],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("value"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value"))
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.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 `passesArgument`, which keeps the call.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "stepsTo",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a"), VALUE_STEP],
-    [(0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a"))],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a"), VALUE_STEP],
+    [(0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "stepsTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("held"), VALUE_STEP],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("held"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("cls"))
     ],
     "class instance"
   ),
   // The receiver a method is called on. Being one of a class is the
   // same hop a construction takes, so a method read off `self` finds
   // what the class declares.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP],
-    [(0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("cls"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("cls"))],
     "receiver instance"
   ),
   // A finder the library declares, keyed on the base a pack named so a
   // project class with a method of the same name on another hierarchy is
   // left alone. The DESIGN says what a chain of them composes into.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.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_datalog5.lit)("givesBackOne", (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("libraryBase", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("givesBackOne", (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("libraryBase", (0, import_datalog6.variable)("cls"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.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_datalog5.lit)("givesBackOneOfArgument", (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("k")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("libraryBase", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("givesBackOneOfArgument", (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("k")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("libraryBase", (0, import_datalog6.variable)("cls"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("givesBackOneOfImport", (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("k")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("givesBackOneOfImport", (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("k")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("cls"))
     ],
     "declared import finder"
   ),
   // A block opened over a library's own constructor. The pack says
   // entering one gives back the object it built, so the name the block
   // opens is that call.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("r"), VALUE_STEP],
+    [(0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("r"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("entersAs", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("entersAsSelf", (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("entersAs", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("entersAsSelf", (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("n"))
     ],
     "context manager returns self"
   ),
   // A method the language says hands back the object it was called on,
   // such as JavaScript's `.bind` or Ruby's `freeze`. Each adapter lists
   // its language's own in `returnsReceiver`, keyed on the method's name.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("o"), VALUE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("o"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("returnsReceiver", (0, import_datalog5.variable)("m"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("returnsReceiver", (0, import_datalog6.variable)("m"))
     ],
     "returns its receiver"
   ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a"), VALUE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("unwraps", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("unwraps", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a"))
     ],
     "factory unwrap"
   ),
   // Wrapper transparency, declared: a pack says module m's n hands back
   // argument k. DESIGN.md says why the argument has to describe a value.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a"), VALUE_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("unwrapsByName", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("k")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("describesValue", (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("unwrapsByName", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("k")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("describesValue", (0, import_datalog6.variable)("a"))
     ],
     "declared wrapper"
   ),
   // A container fills a parameter from the decorator a pack says
   // supplies it, so the parameter is written as that decorator's call.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("d"), VALUE_STEP],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("d"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("decoratedWith", (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("d")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("d"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("suppliesParameter", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("decoratedWith", (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("d")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("d"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("suppliesParameter", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ],
     "supplied by a decorator"
   ),
   // Every value but an object written with nothing in it. The demand
   // rewrite refuses negation, so each kind of value gets a rule.
   ...[
-    (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("a")),
-    (0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("a")),
-    (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("x")),
-    (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-    (0, import_datalog5.lit)("stepsTo", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("kind"))
-  ].map((kind) => (0, import_datalog5.rule)("describesValue", [(0, import_datalog5.variable)("a")], [kind])),
+    (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("a")),
+    (0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("a")),
+    (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("x")),
+    (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+    (0, import_datalog6.lit)("stepsTo", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("kind"))
+  ].map((kind) => (0, import_datalog6.rule)("describesValue", [(0, import_datalog6.variable)("a")], [kind])),
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("ret"), RESULT_STEP],
-    [(0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")), (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("ret"))],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("ret"), RESULT_STEP],
+    [(0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")), (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("ret"))],
     "call result"
   ),
   // A `.then` callback's first parameter is handed what the promise it
   // was chained on settles to, so the parameter steps to that receiver.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("r"), VALUE_STEP],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("r"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("cb"), FIRST_POSITION, (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("t"), FIRST_POSITION, (0, import_datalog5.variable)("cb")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("t"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("r"), THEN_METHOD)
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("cb"), FIRST_POSITION, (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("t"), FIRST_POSITION, (0, import_datalog6.variable)("cb")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("t"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("r"), THEN_METHOD)
     ],
     "then gives"
   ),
   // What a function says it gives back when its body never states a
   // value. The adapter stays quiet about the annotation whenever the
   // body does state one, so the two never answer the same question.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "hop",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"), RESULT_STEP],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"), RESULT_STEP],
     [
-      (0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("returnsClass", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("returnsClass", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("cls"))
     ],
     "declared return type"
   ),
   // Where a walk gets to, under the strongest step it took: value, then
   // instance, then result. The walk so far comes first, so demand stays
   // on the value asked about; the README says what the other order cost.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reaches",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("kind")],
-    [(0, import_datalog5.lit)("stepsTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("kind"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("kind")],
+    [(0, import_datalog6.lit)("stepsTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("kind"))]
   ),
   // A rule per pair rather than one leaving the next step's kind free. A
   // free kind is a second question about the same relation, and a
   // demand-driven run then derives both to answer either.
   ...STEP_LATTICE.map(
-    ({ soFar, next, took }) => (0, import_datalog5.rule)(
+    ({ soFar, next, took }) => (0, import_datalog6.rule)(
       "reaches",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), took],
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), took],
       [
-        (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), soFar),
-        (0, import_datalog5.lit)("stepsTo", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"), next)
+        (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), soFar),
+        (0, import_datalog6.lit)("stepsTo", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"), next)
       ]
     )
   ),
   // A context is an allocation site, or nothing at all for a value read
   // outside every site. Both are stated, so a rule that starts a walk
   // binds its context from a premise rather than from a negation.
-  (0, import_datalog5.rule)("context", [NO_CONTEXT], [], "no context"),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("context", [NO_CONTEXT], [], "no context"),
+  (0, import_datalog6.rule)(
     "context",
-    [(0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))],
+    [(0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))],
     "site context"
   ),
   // The same closure, with the context the walk started under and the
   // context it arrived under. It takes `hop`, because an argument and a
   // property read have their own rules below.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("kind")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("hop", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("kind"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("kind")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("hop", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("kind"))],
     "under one hop"
   ),
   ...STEP_LATTICE.map(
-    ({ soFar, next, took }) => (0, import_datalog5.rule)(
+    ({ soFar, next, took }) => (0, import_datalog6.rule)(
       "reachesUnder",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), took],
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), took],
       [
-        (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("c2"), soFar),
-        (0, import_datalog5.lit)("hop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"), next)
+        (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("c2"), soFar),
+        (0, import_datalog6.lit)("hop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"), next)
       ]
     )
   ),
   // The receiver read under a site is that site. The ordinary hop from a
   // receiver to its class stays in `hop`, so `self` under any context
   // still comes to the class a single-answer reader wants.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c"), VALUE_STEP],
-    [(0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("cls")), (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("cls"))],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c"), VALUE_STEP],
+    [(0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("cls")), (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("cls"))],
     "receiver is the site"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")),
-      (0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")),
+      (0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("cls"))
     ],
     "reached receiver is the site"
   ),
   // The object an expression refers to under a context. A site is an
   // answer here, unlike `objectOf`, and the class an instance is one of
   // is an answer only under no context.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))],
     "site is its own object"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))
     ],
     "name of a site"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("obj")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("obj")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj"))
     ],
     "written object under a context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("obj")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("obj")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("c2"), RESULT_STEP),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("c2"), RESULT_STEP),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj"))
     ],
     "returned object under a context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), NO_CONTEXT, (0, import_datalog5.variable)("cls")],
+    [(0, import_datalog6.variable)("o"), NO_CONTEXT, (0, import_datalog6.variable)("cls")],
     [
-      (0, import_datalog5.lit)(
+      (0, import_datalog6.lit)(
         "reachesUnder",
-        (0, import_datalog5.variable)("o"),
+        (0, import_datalog6.variable)("o"),
         NO_CONTEXT,
-        (0, import_datalog5.variable)("cls"),
+        (0, import_datalog6.variable)("cls"),
         NO_CONTEXT,
         INSTANCE_STEP
       ),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("cls"))
     ],
     "class reached with no context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), NO_CONTEXT, (0, import_datalog5.variable)("cls")],
-    [(0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("cls"))],
+    [(0, import_datalog6.variable)("o"), NO_CONTEXT, (0, import_datalog6.variable)("cls")],
+    [(0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("cls"))],
     "receiver class with no context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOfUnder",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("o")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("o"))],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("o")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("o"))],
     "object under a context is itself"
   ),
   // A property read goes on under the site the object was made at, so a
   // field read off two constructions gives each one its own value. A
   // class or a literal object keeps the context the walk was already in.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("site"), VALUE_STEP],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("site"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "property read at a site"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("c"), VALUE_STEP],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("c"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "property read off an object"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("kind")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("kind")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "reached property read at a site"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "reached property read off an object"
   ),
   // A parameter goes on at the argument, under the context its caller
   // was read in, and only from the calls that run the function under the
   // context the walk is in. This is the one hop that changes context.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("c3"), VALUE_STEP],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("c3"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("i"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("entersUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c3")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("i"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("i"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("entersUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c3")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("i"), (0, import_datalog6.variable)("a"))
     ],
     "argument under a context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("c3"), VALUE_STEP],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("c3"), VALUE_STEP],
     [
-      (0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("entersUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c3")),
-      (0, import_datalog5.lit)("callKeywordArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("entersUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c3")),
+      (0, import_datalog6.lit)("callKeywordArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("a"))
     ],
     "keyword argument under a context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("c3"), (0, import_datalog5.variable)("kind")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("c3"), (0, import_datalog6.variable)("kind")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("i"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("entersUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("c3")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("i"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("i"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("entersUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("c3")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("i"), (0, import_datalog6.variable)("a"))
     ],
     "reached argument under a context"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "reachesUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("c3"), (0, import_datalog5.variable)("kind")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("c3"), (0, import_datalog6.variable)("kind")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("kind")),
-      (0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("entersUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c2"), (0, import_datalog5.variable)("c3")),
-      (0, import_datalog5.lit)("callKeywordArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("kind")),
+      (0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("entersUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c2"), (0, import_datalog6.variable)("c3")),
+      (0, import_datalog6.lit)("callKeywordArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("a"))
     ],
     "reached keyword argument under a context"
   ),
   // Which call runs which function under which context. A construction
   // runs its constructor under the site it makes, a method call runs
   // under the site its receiver is, and anything else under no context.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entersUnder",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("ctor"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("caller")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("ctor"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("caller")],
     [
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("runsConstructor", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("ctor")),
-      (0, import_datalog5.lit)("callUnder", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("caller"))
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("runsConstructor", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("ctor")),
+      (0, import_datalog6.lit)("callUnder", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("caller"))
     ],
     "construction enters its constructor"
   ),
   // When methodCallUnder and objectOfUnder bind as many columns, as they do
   // once contains has run, the rewrite joins the one written first. This
   // order reads the receiver under the call's own sites, not every site.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entersUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("caller")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("caller")],
     [
-      (0, import_datalog5.lit)("methodCallUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("caller")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("caller"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("methodCallUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("caller")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("caller"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("f"))
     ],
     "method call enters under its receiver"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "methodCallUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("caller")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("caller")],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cal")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("cal"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("callUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("caller"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cal")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("cal"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("callUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("caller"))
     ]
   ),
   // A call written as a name runs with whatever receiver the body
   // around it has, so a plain function called from a method keeps the
   // site rather than taking every caller of it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entersUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c")],
     [
-      (0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("callsNamed", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("callUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("callsNamed", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("callUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))
     ],
     "named call enters under the site it is made in"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "entersUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), NO_CONTEXT, (0, import_datalog5.variable)("caller")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), NO_CONTEXT, (0, import_datalog6.variable)("caller")],
     [
-      (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("callUnder", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("caller"))
+      (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("callUnder", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("caller"))
     ],
     "call enters with no context"
   ),
   // The constructor a construction runs, the ancestry included, so a
   // subclass that declares none still fills in what it inherits.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "runsConstructor",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("initializes", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("initializes", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("f"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "runsConstructor",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("runsConstructor", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("runsConstructor", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("f"))
     ]
   ),
   // Which body a call is written in, a closure's calls included. Joining
   // `bodyCalls` on the callee would put every call of a bare name in
   // Python or Ruby in every body that calls that name.
-  (0, import_datalog5.rule)("callInBody", [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r")], [(0, import_datalog5.lit)("makesCall", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("callInBody", [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r")], [(0, import_datalog6.lit)("makesCall", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r"))]),
+  (0, import_datalog6.rule)(
     "callInBody",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r")],
-    [(0, import_datalog5.lit)("containsFn", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("g")), (0, import_datalog5.lit)("callInBody", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("r"))]
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r")],
+    [(0, import_datalog6.lit)("containsFn", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("g")), (0, import_datalog6.lit)("callInBody", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("r"))]
   ),
   // The context a call is made under: every site of the class whose
   // method or constructor it is written in, and no context for a call
   // outside every method body.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("callInBody", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("callInBody", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))
     ],
     "call in a method"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("callInBody", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("initializes", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("callInBody", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("initializes", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))
     ],
     "call in a constructor"
   ),
   // A plain function entered under a site makes its own calls under
   // that site, so a chain of plain functions off one method keeps it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callUnder",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")],
     [
-      (0, import_datalog5.lit)("callOutsideMethod", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callInBody", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("entersUnder", (0, import_datalog5.variable)("into"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c4"))
+      (0, import_datalog6.lit)("callOutsideMethod", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callInBody", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("entersUnder", (0, import_datalog6.variable)("into"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c4"))
     ],
     "call in a function entered under a site"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callUnder",
-    [(0, import_datalog5.variable)("r"), NO_CONTEXT],
-    [(0, import_datalog5.lit)("callOutsideMethod", (0, import_datalog5.variable)("r"))],
+    [(0, import_datalog6.variable)("r"), NO_CONTEXT],
+    [(0, import_datalog6.lit)("callOutsideMethod", (0, import_datalog6.variable)("r"))],
     "call outside every method"
   ),
   // The two questions a caller puts under a context, stopping where
   // `isWrittenAs` and `comesTo` stop, whatever context the walk ended in.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAsUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAsUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAsUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAsUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))
     ]
   ),
   // The fallbacks a value passes under a context, so a value reader treats
   // `a or b` the same way whichever path asked about it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fallbackBehindUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("fallbackBranch", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("fallbackBranch", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fallbackBehindUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("fallbackBranch", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("b"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("fallbackBranch", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("b"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("context", (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("context", (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), VALUE_STEP),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), VALUE_STEP),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), INSTANCE_STEP),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), INSTANCE_STEP),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reachesUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("c2"), INSTANCE_STEP),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reachesUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("c2"), INSTANCE_STEP),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))
     ]
   ),
   // 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_datalog5.rule)("comesTo", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("func", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)("comesTo", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("comesTo", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("func", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)("comesTo", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)(
     "comesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), VALUE_STEP), (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), VALUE_STEP), (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), VALUE_STEP), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), VALUE_STEP), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))]
   ),
   // An instance walk stops the same way, so a method read off
   // `new App()` still finds what the class declares.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), INSTANCE_STEP), (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), INSTANCE_STEP), (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), INSTANCE_STEP), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), INSTANCE_STEP), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "givesBack",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), RESULT_STEP), (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), RESULT_STEP), (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "givesBack",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), RESULT_STEP), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), RESULT_STEP), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))]
   ),
   // `(c) => asyncHandler(fn)` gives back the wrapper's own closure and
   // the fn it unwraps. This is the unwrapped one, which a caller prefers
   // for the same reason `comesTo` wins over `givesBack` on the call.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "givesBackUnwrapped",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r"), RESULT_STEP),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("z")),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r"), RESULT_STEP),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("z")),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.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_datalog5.rule)("isWrittenAs", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)("isWrittenAs", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("isWrittenAs", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)("isWrittenAs", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)(
     "isWrittenAs",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), VALUE_STEP), (0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), VALUE_STEP), (0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAs",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), VALUE_STEP), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), VALUE_STEP), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "isWrittenAs",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("ret")),
-      (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("ret"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("ret")),
+      (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("ret"), (0, import_datalog6.variable)("z"))
     ]
   ),
   // The fallbacks, `a || b`, a value passes on the way to what it is
   // written as. A reader of values takes one whole when every answer came
   // through it, so the reader's own `||` decides which branches count.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fallbackBehind",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("fallbackBranch", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("fallbackBranch", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fallbackBehind",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f"), VALUE_STEP),
-      (0, import_datalog5.lit)("fallbackBranch", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("b"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f"), VALUE_STEP),
+      (0, import_datalog6.lit)("fallbackBranch", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("b"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fallbackBehind",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("ret")),
-      (0, import_datalog5.lit)("fallbackBehind", (0, import_datalog5.variable)("ret"), (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("ret")),
+      (0, import_datalog6.lit)("fallbackBehind", (0, import_datalog6.variable)("ret"), (0, import_datalog6.variable)("f"))
     ]
   ),
   // Which expression running f hands back, whether f returns it, writes
   // it into a name first, or ends on it as a shorthand body.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "returnsCall",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")],
-    [(0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("v")), (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("v"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")],
+    [(0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("v")), (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("v"), (0, import_datalog6.variable)("c"))]
   ),
   // 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 a caller can tell two call sites apart. The callee comes before the
   // parameter, so a walk that starts from the argument asks which function
   // its call runs instead of trying every function with a parameter there.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "passesArgument",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a")],
     [
-      (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "passesArgument",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a")],
     [
-      (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("callKeywordArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("callKeywordArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("a"))
     ]
   ),
   // The expressions that refer to a parameter under another name. An
   // adapter may key a read of the parameter as the parameter itself,
   // or as its own node linked by binds; both arrive here.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToParam",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("p")],
-    [(0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("p"))]
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("p")],
+    [(0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("p"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToParam",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("p")],
-    [(0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p"))]
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("p")],
+    [(0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p"))]
   ),
   // No import step, since no module exports a parameter.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToParam",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p")],
-    [(0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("p")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p")],
+    [(0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("p")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))]
   ),
   // An object the runtime provides and nothing declares: the process
   // environment, or one of the process's output streams. Each is
   // followed the same way, from the spot a pack says spells it.
-  (0, import_datalog5.rule)("runtimeObject", [(0, import_datalog5.variable)("w")], [(0, import_datalog5.lit)("environmentObject", (0, import_datalog5.variable)("w"))]),
-  (0, import_datalog5.rule)("runtimeObject", [(0, import_datalog5.variable)("w")], [(0, import_datalog5.lit)("streamObject", (0, import_datalog5.variable)("w"))]),
+  (0, import_datalog6.rule)("runtimeObject", [(0, import_datalog6.variable)("w")], [(0, import_datalog6.lit)("environmentObject", (0, import_datalog6.variable)("w"))]),
+  (0, import_datalog6.rule)("runtimeObject", [(0, import_datalog6.variable)("w")], [(0, import_datalog6.lit)("streamObject", (0, import_datalog6.variable)("w"))]),
   // An expression whose value is the runtime object w: the way a pack
   // spells it, a name declared as that, or a parameter a caller handed
   // one of those to, however many calls deep.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "runtimeValue",
-    [(0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o")],
-    [(0, import_datalog5.lit)("runtimeObject", (0, import_datalog5.variable)("w")), (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("w"))]
+    [(0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o")],
+    [(0, import_datalog6.lit)("runtimeObject", (0, import_datalog6.variable)("w")), (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("w"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "runtimeValue",
-    [(0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o")],
+    [(0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o")],
     [
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p"))
     ]
   ),
   // A parameter that defaults to the environment, for the callers that
   // pass nothing. `loadConfig(env = process.env)` is written that way
   // so that most of the program never mentions the environment at all.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "runtimeValue",
-    [(0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o")],
+    [(0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o")],
     [
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("d")),
-      (0, import_datalog5.lit)("paramDefault", (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("d")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("d")),
+      (0, import_datalog6.lit)("paramDefault", (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("d")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p"))
     ]
   ),
   // Which environment object a keyed read takes its entry from. The
   // object comes first because a project writes a handful of those and
   // thousands of keyed reads, and the join starts at the small end.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "environmentRead",
-    [(0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("x")],
+    [(0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("x")],
     [
-      (0, import_datalog5.lit)("environmentObject", (0, import_datalog5.variable)("w")),
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("readsKeyed", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("x"))
+      (0, import_datalog6.lit)("environmentObject", (0, import_datalog6.variable)("w")),
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("readsKeyed", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("x"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "readsEnvNamed",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("environmentRead", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("environmentRead", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("x"))]
   ),
   // A parameter whose value is an environment variable's name: a read
   // site takes its name from it, or it is handed on to a parameter that
   // does. Asked from the site, so the recursion runs callee to caller.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "paramNamesEnv",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("readsEnvNamed", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("readsEnvNamed", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "paramNamesEnv",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("q"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("paramNamesEnv", (0, import_datalog5.variable)("q"), (0, import_datalog5.variable)("site"))
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("q"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("paramNamesEnv", (0, import_datalog6.variable)("q"), (0, import_datalog6.variable)("site"))
     ]
   ),
   // The class some declaration says a value is one of: its own, or that of
   // anything the value steps to, a caller's argument included. Two callers
   // can disagree, so the asking side decides whether it got one.
-  (0, import_datalog5.rule)("typedAs", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("t")], [(0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("t"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("typedAs", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("t")], [(0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("t"))]),
+  (0, import_datalog6.rule)(
     "typedAs",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("t")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("t")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), VALUE_STEP),
-      (0, import_datalog5.lit)("instanceOf", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("t"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), VALUE_STEP),
+      (0, import_datalog6.lit)("instanceOf", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("t"))
     ]
   ),
   // Which module's export a re-exported name forwards to, however
   // many barrels deep the forwarding runs.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "moduleForwards",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2")],
-    [(0, import_datalog5.lit)("reExports", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2"))]
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2")],
+    [(0, import_datalog6.lit)("reExports", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "moduleForwards",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m3"), (0, import_datalog5.variable)("n3")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m3"), (0, import_datalog6.variable)("n3")],
     [
-      (0, import_datalog5.lit)("reExports", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2")),
-      (0, import_datalog5.lit)("moduleForwards", (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2"), (0, import_datalog5.variable)("m3"), (0, import_datalog5.variable)("n3"))
+      (0, import_datalog6.lit)("reExports", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2")),
+      (0, import_datalog6.lit)("moduleForwards", (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2"), (0, import_datalog6.variable)("m3"), (0, import_datalog6.variable)("n3"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "moduleExport",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value")],
-    [(0, import_datalog5.lit)("exportsAs", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value"))],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value")],
+    [(0, import_datalog6.lit)("exportsAs", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value"))],
     "export"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "moduleExport",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value")],
     [
-      (0, import_datalog5.lit)("reExports", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2"), (0, import_datalog5.variable)("value"))
+      (0, import_datalog6.lit)("reExports", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2"), (0, import_datalog6.variable)("value"))
     ],
     "re-export"
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "moduleExport",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value")],
     [
-      (0, import_datalog5.lit)("reExportsAll", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("m2")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value"))
+      (0, import_datalog6.lit)("reExportsAll", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("m2")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "invokes",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f"))]
   ),
   // The callee is itself a call: `daoBuilder()()`.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "invokes",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("givesBack", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("givesBack", (0, import_datalog6.variable)("c"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOf",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")],
-    [(0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj"))]
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")],
+    [(0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOf",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj")],
-    [(0, import_datalog5.lit)("givesBack", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj")), (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj")],
+    [(0, import_datalog6.lit)("givesBack", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj")), (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj"))]
   ),
   // A construction is the object it made, and so is any name for it.
   // The class stays an answer too, so an instance whose site is not in
   // the run still reads what the class stores.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOf",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOf",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("site"), VALUE_STEP),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("site"), VALUE_STEP),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c"))
     ]
   ),
   // So is one a call hands back when it passes no arguments, as
   // `get_settings()` hands back `Settings()`, since only the construction
   // contains the field defaults its class declares.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "objectOf",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("site"), RESULT_STEP),
-      (0, import_datalog5.lit)("callArgCount", (0, import_datalog5.variable)("site"), NO_ARGUMENTS),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("site"), RESULT_STEP),
+      (0, import_datalog6.lit)("callArgCount", (0, import_datalog6.variable)("site"), NO_ARGUMENTS),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c"))
     ]
   ),
   // Which calls a function, found by the name the call is written as
@@ -3938,114 +4098,114 @@ var STATED_RULES = [
   // 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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsNamed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f")), (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f")), (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsNamed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsNamed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("d"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("d")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("d"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("d")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))
     ]
   ),
   // `const f = (x) => ...` declares the name and puts the parameters on
   // the arrow, so everything above arrives at the declaration and
   // `paramOf` is about the arrow. One binds hop joins the two.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsNamed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("f")), (0, import_datalog5.lit)("callsNamed", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("g"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("f")), (0, import_datalog6.lit)("callsNamed", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("g"))]
   ),
   // Every one of those, and the binds hop again over the whole
   // relation, so a property holding a name for a function is reached
   // the way it was before the two were told apart.
-  (0, import_datalog5.rule)("callsFunction", [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")], [(0, import_datalog5.lit)("callsNamed", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("callsFunction", [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")], [(0, import_datalog6.lit)("callsNamed", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"))]),
+  (0, import_datalog6.rule)(
     "callsFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("f")), (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("g"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("f")), (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("g"))]
   ),
   // A function written on an object, called off it: `client.get(o)`.
   // The receiver comes from the object through `refersToObject`, not from
   // `objectOf`: a walk from every reader of the name was most of a run.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))
     ]
   ),
   // A name bound to a factory's result, called: `const get =
   // makeReader(env)` then `get(name)`. Written from the factory's call so
   // the walk starts where `callsFunction` already has an answer.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r0"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("callsNamed", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("r0"))
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r0"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("callsNamed", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("r0"))
     ]
   ),
   // The same, called straight off the factory's call, as
   // `register("created")(handler)` or a Python decorator written that way.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("callsFunction", (0, import_datalog5.variable)("r0"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("r0"))
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("callsFunction", (0, import_datalog6.variable)("r0"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("r0"))
     ]
   ),
   // The expressions that refer to an object under another name, through
   // a name hop or an import. Asked from the object, so it visits only
   // them.
-  (0, import_datalog5.rule)("refersToObject", [(0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("obj")], [(0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("obj"))]),
+  (0, import_datalog6.rule)("refersToObject", [(0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("obj")], [(0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("obj"))]),
   // A construction is an object too, and the one a name for it refers to.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToObject",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c"))]
   ),
   // The process environment and the output streams are objects nothing
   // declares, so a pack saying which expression spells one is the only
   // way in.
-  (0, import_datalog5.rule)("refersToObject", [(0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("w")], [(0, import_datalog5.lit)("runtimeObject", (0, import_datalog5.variable)("w"))]),
+  (0, import_datalog6.rule)("refersToObject", [(0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("w")], [(0, import_datalog6.lit)("runtimeObject", (0, import_datalog6.variable)("w"))]),
   // The hop comes first so a check with both ends bound walks forward from
   // the name, which the named store needs. With one end bound, the bound
   // literal goes first whatever order the body is written in.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToObject",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj")],
-    [(0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("obj"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj")],
+    [(0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("obj"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "refersToObject",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj")],
     [
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("obj"))
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("obj"))
     ]
   ),
   // What an object contains, its base class included, so a method the base
@@ -4053,417 +4213,418 @@ var STATED_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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
-    [(0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))]
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
+    [(0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("baseCls")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("baseCls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("baseCls")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("baseCls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     BASE_CLASS_RULE
   ),
   // A module a Ruby class prepends is an ancestor too. It comes before the
   // class in lookup, which `overrides` says, so it has a relation of its own.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("prepends", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("mod")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("modObj")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("modObj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("prepends", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("mod")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("modObj")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("modObj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "prepended module"
   ),
   // An association is read off an instance as a property, and stating
   // it as `contains` is what puts it on the ancestry rule, so a concern
   // or a base class can be the one that declares it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("t")],
-    [(0, import_datalog5.lit)("declaresAssociation", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("t"))],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("t")],
+    [(0, import_datalog6.lit)("declaresAssociation", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("t"))],
     "declared association"
   ),
   // The same, for a language that buries the declaration in an ordinary
   // assignment. Keying on the module the callable came from is what
   // keeps a project function spelled the same way out.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("t")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("t")],
     [
-      (0, import_datalog5.lit)("fieldCall", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("t")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("name")),
-      (0, import_datalog5.lit)("associationConstructor", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("name"))
+      (0, import_datalog6.lit)("fieldCall", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("t")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("name")),
+      (0, import_datalog6.lit)("associationConstructor", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("name"))
     ],
     "constructed association"
   ),
   // What the constructor put on the receiver. The class is the object
   // for an instance whose own site is not in the run.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("initializes", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("storesProperty", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"), RECEIVER_STORE)
+      (0, import_datalog6.lit)("initializes", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("storesProperty", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"), RECEIVER_STORE)
     ],
     "constructor store"
   ),
   // What any other method of the class put there. Two methods writing
   // one name give two rows, since nothing here orders them.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("storesProperty", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"), RECEIVER_STORE)
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("storesProperty", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"), RECEIVER_STORE)
     ],
     "method store"
   ),
   // A write through a name, `client.timeout = 5`, lands on the object the
   // name refers to. The writes to the property asked about come off an
   // index, and each name is checked forward against the one object.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("storesProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"), NAMED_STORE),
-      (0, import_datalog5.lit)("refersToObject", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"))
+      (0, import_datalog6.lit)("storesProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"), NAMED_STORE),
+      (0, import_datalog6.lit)("refersToObject", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"))
     ],
     "named store"
   ),
   // A member a class declares itself under a name one of its bases also
   // contains. `contains` keeps both, and a caller that needs one answer
   // prefers the member declared nearer the object the read went through.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "overrides",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h")],
     [
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
   // The same for a field default, which a plain subclass contains too.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "overrides",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h")],
     [
-      (0, import_datalog5.lit)("declaresDefault", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+      (0, import_datalog6.lit)("declaresDefault", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
   // A prepended module's member comes before the class's own and what the
   // class inherits. The module is found by a name hop, since `comesTo`
   // asked backwards from the module walks to it from every value.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "overrides",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h")],
     [
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("modObj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("modObj")),
-      (0, import_datalog5.lit)("prepends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("mod")),
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("modObj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("modObj")),
+      (0, import_datalog6.lit)("prepends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("mod")),
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "overrides",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h")],
-    [
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("modObj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("mod"), (0, import_datalog5.variable)("modObj")),
-      (0, import_datalog5.lit)("prepends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("mod")),
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h")],
+    [
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("modObj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("mod"), (0, import_datalog6.variable)("modObj")),
+      (0, import_datalog6.lit)("prepends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("mod")),
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
   // The objects a read reads a name off, and on each one the members the
   // read finds that another member there overrides.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "readsFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("obj"))
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("obj"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "readsOverridden",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h")],
     [
-      (0, import_datalog5.lit)("readsFrom", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("overrides", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+      (0, import_datalog6.lit)("readsFrom", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("overrides", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
   // Every member, for a read with an override, so `contains` is asked with
   // the object and name bound, the way the property read already asks it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "readsMemberOn",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h")],
     [
-      (0, import_datalog5.lit)("readsOverridden", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("shadowing"), (0, import_datalog5.variable)("overridden")),
-      (0, import_datalog5.lit)("readsFrom", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("h"))
+      (0, import_datalog6.lit)("readsOverridden", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("shadowing"), (0, import_datalog6.variable)("overridden")),
+      (0, import_datalog6.lit)("readsFrom", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("h"))
     ]
   ),
   // A call written with a class's own name, which is how most languages
   // spell a construction. A language that spells one some other way
   // states its own rule for this, the way Ruby does for `Const.new`.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "constructsNamed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls")],
-    [(0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls")), (0, import_datalog5.lit)("callsNamed", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cls"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls")],
+    [(0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("cls")), (0, import_datalog6.lit)("callsNamed", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cls"))]
   ),
   // Each construction is an object of its own containing what its
   // class stores, so two sites are two objects.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("contains", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("contains", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "allocated instance"
   ),
   // A construction written with no arguments keeps every field default its
   // class declares. Any argument could fill a field through a constructor
   // the run cannot see, and a finder's result was built somewhere else.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("callArgCount", (0, import_datalog5.variable)("site"), NO_ARGUMENTS),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("fieldDefault", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("callArgCount", (0, import_datalog6.variable)("site"), NO_ARGUMENTS),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("fieldDefault", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     "construction with no arguments"
   ),
   // On a plain class nothing generates a constructor that could replace
   // an annotated attribute, so every instance shares it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "contains",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("declaresDefault", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")),
-      (0, import_datalog5.lit)("plainAncestry", (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("declaresDefault", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")),
+      (0, import_datalog6.lit)("plainAncestry", (0, import_datalog6.variable)("cls"))
     ],
     "plain class attribute"
   ),
   // A class nothing generates a constructor for. The adapter states it
   // only where the source shows it, since a rule cannot say "unless", and
   // a class written over one base is plain when that base is.
-  (0, import_datalog5.rule)("plainAncestry", [(0, import_datalog5.variable)("c")], [(0, import_datalog5.lit)("plainClass", (0, import_datalog5.variable)("c"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("plainAncestry", [(0, import_datalog6.variable)("c")], [(0, import_datalog6.lit)("plainClass", (0, import_datalog6.variable)("c"))]),
+  (0, import_datalog6.rule)(
     "plainAncestry",
-    [(0, import_datalog5.variable)("c")],
+    [(0, import_datalog6.variable)("c")],
     [
-      (0, import_datalog5.lit)("extendsOnly", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("baseCls")),
-      (0, import_datalog5.lit)("plainAncestry", (0, import_datalog5.variable)("baseCls"))
+      (0, import_datalog6.lit)("extendsOnly", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("baseCls")),
+      (0, import_datalog6.lit)("plainAncestry", (0, import_datalog6.variable)("baseCls"))
     ]
   ),
   // A field default, its base class's included. It stays out of `contains`,
   // which every instance reads, because a constructor may replace it.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fieldDefault",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
-    [(0, import_datalog5.lit)("declaresDefault", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))]
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
+    [(0, import_datalog6.lit)("declaresDefault", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "fieldDefault",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("base")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("base"), (0, import_datalog5.variable)("baseCls")),
-      (0, import_datalog5.lit)("fieldDefault", (0, import_datalog5.variable)("baseCls"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("base")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("base"), (0, import_datalog6.variable)("baseCls")),
+      (0, import_datalog6.lit)("fieldDefault", (0, import_datalog6.variable)("baseCls"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ],
     BASE_CLASS_RULE
   ),
   // A call that makes one of a class. Every finder a pack declared is
   // one too, so `User.find(1)` is a site the same way `User.new` is.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "allocates",
-    [(0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")],
+    [(0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("stepsTo", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"), INSTANCE_STEP)
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("stepsTo", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"), INSTANCE_STEP)
     ],
     "allocation site"
   ),
   // The library base a class's ancestry arrives at, however many of a
   // project's own classes sit in between. A base the run declares has a
   // node to keep walking from; one it does not has only a name.
-  (0, import_datalog5.rule)("libraryBase", [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")], [(0, import_datalog5.lit)("extendsNamed", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("libraryBase", [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")], [(0, import_datalog6.lit)("extendsNamed", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n"))]),
+  (0, import_datalog6.rule)(
     "libraryBase",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("libraryBase", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("libraryBase", (0, import_datalog6.variable)("b"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "libraryBase",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("cc")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("cc"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("cc")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("cc"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "returnsFunc",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("g")],
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("g")],
     [
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("value")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("value"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("g"))
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("value")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("value"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.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_datalog5.rule)("bodyCallsDeep", [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")], [(0, import_datalog5.lit)("bodyCalls", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("bodyCallsDeep", [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")], [(0, import_datalog6.lit)("bodyCalls", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"))]),
+  (0, import_datalog6.rule)(
     "bodyCallsDeep",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")],
-    [(0, import_datalog5.lit)("containsFn", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("g")), (0, import_datalog5.lit)("bodyCallsDeep", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")],
+    [(0, import_datalog6.lit)("containsFn", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("g")), (0, import_datalog6.lit)("bodyCallsDeep", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("c"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "unwraps",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k")],
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k")],
     [
-      (0, import_datalog5.lit)("returnsFunc", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("bodyCallsDeep", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("returnsFunc", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("bodyCallsDeep", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("p"))
     ]
   ),
   // Which parameter a value traces back to: the parameter under any name,
   // or a call passing it to another factory that unwraps, which is how
   // `createProtected(h) { return service.withAuth(h); }` unwraps.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "flowsToParam",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p")],
-    [(0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p")],
+    [(0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "flowsToParam",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("unwraps", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("flowsToParam", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("unwraps", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("flowsToParam", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("p"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "unwraps",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k")],
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k")],
     [
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("value")),
-      (0, import_datalog5.lit)("flowsToParam", (0, import_datalog5.variable)("value"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("value")),
+      (0, import_datalog6.lit)("flowsToParam", (0, import_datalog6.variable)("value"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("p"))
     ]
   ),
   // Where a name comes from, when what it refers to lives outside the
   // source being read. A walk ends at what the source writes out, so it
   // never reaches a library's own function; these rules do.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), VALUE_STEP),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), VALUE_STEP),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ]
   ),
   // A member read off a whole-module import: the member's own name is
   // what the module exports, so `fastapi.APIRouter` comes from
   // fastapi's `APIRouter`. Directly, or through a name for the module.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("ns"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("ns"), (0, import_datalog5.variable)("m"), NAMESPACE_IMPORT)
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("ns"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("ns"), (0, import_datalog6.variable)("m"), NAMESPACE_IMPORT)
     ],
     NAMESPACE_MEMBER_RULE
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("ns"), VALUE_STEP),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("ns"), (0, import_datalog5.variable)("m"), NAMESPACE_IMPORT)
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("ns"), VALUE_STEP),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("ns"), (0, import_datalog6.variable)("m"), NAMESPACE_IMPORT)
     ],
     NAMESPACE_MEMBER_RULE
   ),
   // A CommonJS module hands its exports over as the default, so after
   // `import React from "react"`, `React.memo` is react's `memo`.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "comesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("d"), VALUE_STEP),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("d"), (0, import_datalog5.variable)("m"), DEFAULT_IMPORT)
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("d"), VALUE_STEP),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("d"), (0, import_datalog6.variable)("m"), DEFAULT_IMPORT)
     ],
     NAMESPACE_MEMBER_RULE
   ),
   // Calling f ends up calling the name n that module m exports, one
   // hop through f's own body or deeper through a wrapper of a wrapper.
   // Several results is normal: a composed decorator applies them all.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsInto",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("bodyCallsDeep", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("bodyCallsDeep", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callsInto",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("bodyCallsDeep", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("callsInto", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("bodyCallsDeep", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("callsInto", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "resolves",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")), (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")), (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("z"))]
   ),
   ...DISPATCH_RULES,
-  ...PASSED_ON_RULES
+  ...PASSED_ON_RULES,
+  ...SELF_RULES
 ];
 function alsoSteps(rules) {
   return [
@@ -4474,52 +4635,52 @@ function alsoSteps(rules) {
 var RESOLUTION_RULES = alsoSteps(STATED_RULES);
 var SOURCE_STEPS = [VALUE_STEP, RESULT_STEP];
 var WRITTEN_KEY_READS = [
-  (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")),
-  (0, import_datalog5.lit)("readsEntry", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"))
+  (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")),
+  (0, import_datalog6.lit)("readsEntry", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"))
 ];
 var SOURCE_READS = [
   ...WRITTEN_KEY_READS,
-  (0, import_datalog5.lit)("readsKeyed", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("k"))
+  (0, import_datalog6.lit)("readsKeyed", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("k"))
 ];
 function writtenAnswers(asking) {
   return [
-    (0, import_datalog5.rule)(
+    (0, import_datalog6.rule)(
       "wantedIsWrittenAs",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-      [(0, import_datalog5.lit)(asking, (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+      [(0, import_datalog6.lit)(asking, (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
     ),
-    (0, import_datalog5.rule)(
+    (0, import_datalog6.rule)(
       "wantedFallbackBehind",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
-      [(0, import_datalog5.lit)(asking, (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("fallbackBehind", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f"))]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
+      [(0, import_datalog6.lit)(asking, (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("fallbackBehind", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f"))]
     ),
-    (0, import_datalog5.rule)(
+    (0, import_datalog6.rule)(
       "wantedReadsOverridden",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h")],
-      [(0, import_datalog5.lit)(asking, (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("readsOverridden", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h"))]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h")],
+      [(0, import_datalog6.lit)(asking, (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("readsOverridden", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h"))]
     ),
-    (0, import_datalog5.rule)(
+    (0, import_datalog6.rule)(
       "wantedReadsMemberOn",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h")],
-      [(0, import_datalog5.lit)(asking, (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("readsMemberOn", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("obj"), (0, import_datalog5.variable)("h"))]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h")],
+      [(0, import_datalog6.lit)(asking, (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("readsMemberOn", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("obj"), (0, import_datalog6.variable)("h"))]
     )
   ];
 }
 var RESOLUTION_QUESTIONS = [
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedResolves",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("resolves", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("resolves", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedComesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedComesTo",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("wantedOrigin", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("wantedOrigin", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
   ...writtenAnswers("wanted"),
   // A caller that reads only what a value is written as asks this way,
@@ -4528,666 +4689,667 @@ var RESOLUTION_QUESTIONS = [
   // A call is given no `comesTo`, so this is the only way to ask what
   // object one arrives at, and a demand-driven run derives `objectOf`
   // nowhere without it. An allocation site is not one of the answers.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedObjectOf",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("objectOf", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")),
-      (0, import_datalog5.lit)("objectValue", (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("objectOf", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")),
+      (0, import_datalog6.lit)("objectValue", (0, import_datalog6.variable)("z"))
     ]
   ),
   // The same three questions under one allocation site, keyed by the
   // value and the site both. An allocation site is an answer here,
   // unlike `wantedObjectOf`, since a site is what a context is.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedIsWrittenAsUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("wantedUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("isWrittenAsUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("wantedUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("isWrittenAsUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"))
     ]
   ),
   // Where a class was made, for a caller about to ask a value question
   // under each. Going through `constructsNamed` keeps the demand on the
   // calls written with the class's name rather than on every call.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedAllocatedAt",
-    [(0, import_datalog5.variable)("cls"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("cls"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("wantedSites", (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("constructsNamed", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls")),
-      (0, import_datalog5.lit)("allocates", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("cls"))
+      (0, import_datalog6.lit)("wantedSites", (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("constructsNamed", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls")),
+      (0, import_datalog6.lit)("allocates", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("cls"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedComesToUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("wantedUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesToUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("wantedUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesToUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedObjectOfUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("wantedUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("objectOfUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("wantedUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("objectOfUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedFallbackBehindUnder",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("wantedUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("fallbackBehindUnder", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("wantedUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("fallbackBehindUnder", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f"))
     ]
   ),
   // 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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedGivesBack",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("givesBack", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("givesBack", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedGivesBackUnwrapped",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("givesBackUnwrapped", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("givesBackUnwrapped", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
   // The argument as the caller wrote it, keyed by the parameter, since
   // that is what a caller has in hand when it wants the call sites told
   // apart. The caller settles the argument however its kind of value needs.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedPassesArgument",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("p")), (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a"))]
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("p")), (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedReturnsCall",
-    [(0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("f")), (0, import_datalog5.lit)("returnsCall", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("f")), (0, import_datalog6.lit)("returnsCall", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("c"))]
   ),
   // Seeded with the expressions that spell the environment, a handful
   // per project. The reads cannot be the seed: one written through a
   // parameter is nowhere a scan of the source looks.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedParamNamesEnv",
-    [(0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("wantedEnvObject", (0, import_datalog5.variable)("w")),
-      (0, import_datalog5.lit)("environmentRead", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("paramNamesEnv", (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("site"))
+      (0, import_datalog6.lit)("wantedEnvObject", (0, import_datalog6.variable)("w")),
+      (0, import_datalog6.lit)("environmentRead", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("paramNamesEnv", (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("site"))
     ]
   ),
   // The parameters the environment object is handed to, from the same
   // seed, so a question about one is a lookup rather than a read of
   // every file that could call its function.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedEnvParameter",
-    [(0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("wantedEnvObject", (0, import_datalog5.variable)("w")),
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("wantedEnvObject", (0, import_datalog6.variable)("w")),
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p"))
     ]
   ),
   // The calls that hand it on, for an asker to resolve, since the
   // parameter on the other side is in a file nothing has read yet.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedEnvPassingCall",
-    [(0, import_datalog5.variable)("r")],
+    [(0, import_datalog6.variable)("r")],
     [
-      (0, import_datalog5.lit)("wantedEnvObject", (0, import_datalog5.variable)("w")),
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("wantedEnvObject", (0, import_datalog6.variable)("w")),
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a"))
     ]
   ),
   // The same relation asked from one expression. Seeding from the
   // objects instead would settle it for every expression in the
   // project, and a caller holding an argument wants only that one.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedEnvironmentValue",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("w")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("w")],
     [
-      (0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("environmentObject", (0, import_datalog5.variable)("w"))
+      (0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("environmentObject", (0, import_datalog6.variable)("w"))
     ]
   ),
   // Every expression an output stream reaches, from the spots that spell
   // one, so a writer at `out.write(...)` looks its receiver up.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedStreamValue",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("w")],
-    [(0, import_datalog5.lit)("wantedStreamObject", (0, import_datalog5.variable)("w")), (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("o"))]
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("w")],
+    [(0, import_datalog6.lit)("wantedStreamObject", (0, import_datalog6.variable)("w")), (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("o"))]
   ),
   // The functions whose return becomes the exit code: a call the value
   // that ends up as the code is, or one it reaches. DESIGN.md has the seeds.
-  (0, import_datalog5.rule)("exitStart", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("wantedExitSink", (0, import_datalog5.variable)("x"))]),
+  (0, import_datalog6.rule)("exitStart", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("wantedExitSink", (0, import_datalog6.variable)("x"))]),
   // `reaches` takes no step through a call that picks its function from a
   // table, so the walk starts again from what each function there returns.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "exitStart",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("ret")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("ret")],
     [
-      (0, import_datalog5.lit)("exitReached", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("dispatchesTo", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("returnsValue", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("ret"))
+      (0, import_datalog6.lit)("exitReached", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("dispatchesTo", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("returnsValue", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("ret"))
     ]
   ),
-  (0, import_datalog5.rule)("exitReached", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("s")], [(0, import_datalog5.lit)("exitStart", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("s"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("exitReached", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("s")], [(0, import_datalog6.lit)("exitStart", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("s"))]),
+  (0, import_datalog6.rule)(
     "exitReached",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")],
     [
-      (0, import_datalog5.lit)("exitStart", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("s")),
-      (0, import_datalog5.lit)("reaches", (0, import_datalog5.variable)("s"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("kind"))
+      (0, import_datalog6.lit)("exitStart", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("s")),
+      (0, import_datalog6.lit)("reaches", (0, import_datalog6.variable)("s"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("kind"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedExitCodeFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("exitReached", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("exitReached", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("f"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedExitCodeFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("exitReached", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("dispatchesTo", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("exitReached", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("dispatchesTo", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("f"))]
   ),
   // The functions a call may run when it takes one from a table, with the
   // entry each came from, and the entries that come to no function. The
   // reader in dispatch.ts decides whether the call runs exactly one.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchSite",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
-    [(0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")), (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site"))]
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
+    [(0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")), (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchEntry",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("entryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("entryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchInBranch",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryInBranch", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryInBranch", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchComputed",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("computedEntryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("computedEntryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("entryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("held")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("entryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("held")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("f"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchLikeEntry",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("likeEntryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("likeEntryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchLikeFunction",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("callsEntryAt", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("site")),
-      (0, import_datalog5.lit)("likeEntryAt", (0, import_datalog5.variable)("site"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("held"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("func", (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("callsEntryAt", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("site")),
+      (0, import_datalog6.lit)("likeEntryAt", (0, import_datalog6.variable)("site"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("held"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("func", (0, import_datalog6.variable)("f"))
     ]
   ),
   // What a function there calls in its own body, for an entry written as
   // a lambda, which no summary describes.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDispatchThrough",
-    [(0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("g")],
+    [(0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("g")],
     [
-      (0, import_datalog5.lit)("wantedDispatch", (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("dispatchesTo", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("f")),
-      (0, import_datalog5.lit)("makesCall", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("r2")),
-      (0, import_datalog5.lit)("invokes", (0, import_datalog5.variable)("r2"), (0, import_datalog5.variable)("g"))
+      (0, import_datalog6.lit)("wantedDispatch", (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("dispatchesTo", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("f")),
+      (0, import_datalog6.lit)("makesCall", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("r2")),
+      (0, import_datalog6.lit)("invokes", (0, import_datalog6.variable)("r2"), (0, import_datalog6.variable)("g"))
     ]
   ),
   // The calls that hand a stream on, so the asker can read the callee's file.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedStreamPassingCall",
-    [(0, import_datalog5.variable)("r")],
+    [(0, import_datalog6.variable)("r")],
     [
-      (0, import_datalog5.lit)("wantedStreamObject", (0, import_datalog5.variable)("w")),
-      (0, import_datalog5.lit)("runtimeValue", (0, import_datalog5.variable)("w"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("callArg", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("wantedStreamObject", (0, import_datalog6.variable)("w")),
+      (0, import_datalog6.lit)("runtimeValue", (0, import_datalog6.variable)("w"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("callArg", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("a"))
     ]
   ),
   // Whether an expression is a parameter under another name, for a
   // caller deciding whether going and reading that parameter's callers
   // could change the answer it already has.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedRefersToParam",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")],
-    [(0, import_datalog5.lit)("wanted", (0, import_datalog5.variable)("o")), (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p"))]
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")],
+    [(0, import_datalog6.lit)("wanted", (0, import_datalog6.variable)("o")), (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p"))]
   ),
   // The types a value is declared as, beside each argument its own
   // callers pass, so the asking side can refuse a caller passing
   // something no declaration types.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedTypedAs",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("t")],
-    [(0, import_datalog5.lit)("wantedType", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("typedAs", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("t"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("t")],
+    [(0, import_datalog6.lit)("wantedType", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("typedAs", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("t"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedTypePassed",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("a")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("a")],
     [
-      (0, import_datalog5.lit)("wantedType", (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a"))
+      (0, import_datalog6.lit)("wantedType", (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedPassedTypedAs",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("t")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("t")],
     [
-      (0, import_datalog5.lit)("wantedType", (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("typedAs", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("t"))
+      (0, import_datalog6.lit)("wantedType", (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("typedAs", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("t"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedPassedParam",
-    [(0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("a")],
+    [(0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("a")],
     [
-      (0, import_datalog5.lit)("wantedType", (0, import_datalog5.variable)("o")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("passesArgument", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("a")),
-      (0, import_datalog5.lit)("refersToParam", (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("q"))
+      (0, import_datalog6.lit)("wantedType", (0, import_datalog6.variable)("o")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("passesArgument", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("a")),
+      (0, import_datalog6.lit)("refersToParam", (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("q"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedComesFrom",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("wantedOrigin", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("wantedOrigin", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)("callOriginChain", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("wantedCallOrigin", (0, import_datalog5.variable)("x"))]),
+  (0, import_datalog6.rule)("callOriginChain", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("wantedCallOrigin", (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callOriginChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("callOriginChainStepped", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("callOriginChainStepped", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callOriginChainStepped",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.variable)("n2")],
     [
-      (0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("moduleForwards", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("m2"), (0, import_datalog5.variable)("n2"))
+      (0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("moduleForwards", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("m2"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("m"), NAMESPACE_IMPORT),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("d"), (0, import_datalog5.variable)("m"), NAMESPACE_IMPORT),
-      (0, import_datalog5.lit)("binds", (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("d")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("d"), (0, import_datalog6.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog6.lit)("binds", (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("d")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))
     ]
   ),
   // What a call made: through the call to its callee, whose own alias
   // chain leads to the import.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callMadeChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f")],
-    [(0, import_datalog5.lit)("callOriginChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")), (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f")],
+    [(0, import_datalog6.lit)("callOriginChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")), (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callMadeChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("callMadeChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("callMadeChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginPair",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("callMadeChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("callMadeChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ]
   ),
   // A member destructured off what a call made keeps the member name
   // as one more path segment.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callMemberChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("callOriginChainStepped", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("e")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("e"), (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("f"))
+      (0, import_datalog6.lit)("callOriginChainStepped", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("e")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("e"), (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("f"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "callMemberChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("callMemberChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("callMemberChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallOriginMember",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p")],
     [
-      (0, import_datalog5.lit)("callMemberChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("callMemberChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallsInto",
-    [(0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("wantedOrigin", (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("comesTo", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("g")),
-      (0, import_datalog5.lit)("callsInto", (0, import_datalog5.variable)("g"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("wantedOrigin", (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("comesTo", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("g")),
+      (0, import_datalog6.lit)("callsInto", (0, import_datalog6.variable)("g"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSubjectWritten",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")],
-    [(0, import_datalog5.lit)("wantedSubject", (0, import_datalog5.variable)("x")), (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")],
+    [(0, import_datalog6.lit)("wantedSubject", (0, import_datalog6.variable)("x")), (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSubjectConstruction",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("wantedSubject", (0, import_datalog5.variable)("x")),
-      (0, import_datalog5.lit)("isWrittenAs", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c")),
-      (0, import_datalog5.lit)("comesFrom", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("wantedSubject", (0, import_datalog6.variable)("x")),
+      (0, import_datalog6.lit)("isWrittenAs", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c")),
+      (0, import_datalog6.lit)("comesFrom", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("m"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedModuleExport",
-    [(0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value")],
+    [(0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value")],
     [
-      (0, import_datalog5.lit)("wantedExportsOf", (0, import_datalog5.variable)("m")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("value"))
+      (0, import_datalog6.lit)("wantedExportsOf", (0, import_datalog6.variable)("m")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("value"))
     ]
   ),
   // A class's ancestry: each base as written, then the class that name
   // comes to through the name hops. A storage pack matches its library's
   // bases against the base names along the way.
-  (0, import_datalog5.rule)("ancestryChain", [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("c")], [(0, import_datalog5.lit)("wantedAncestry", (0, import_datalog5.variable)("c"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("ancestryChain", [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("c")], [(0, import_datalog6.lit)("wantedAncestry", (0, import_datalog6.variable)("c"))]),
+  (0, import_datalog6.rule)(
     "ancestryChain",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")), (0, import_datalog5.lit)("extends", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")), (0, import_datalog6.lit)("extends", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "ancestryChain",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("x")],
-    [(0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")), (0, import_datalog5.lit)("prepends", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("x"))]
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("x")],
+    [(0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")), (0, import_datalog6.lit)("prepends", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("x"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "ancestryChain",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "ancestryChain",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedBaseName",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")), (0, import_datalog5.lit)("extendsNamed", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")), (0, import_datalog6.lit)("extendsNamed", (0, import_datalog6.variable)("b"), (0, import_datalog6.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_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDeclaredName",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ]
   ),
   // A method the class gets under a name the source computes rather than
   // writes out. The adapter settles the name against the same facts and
   // says so, and the chain reports it beside the ones written out.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedDeclaredName",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("n")],
-    [(0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")), (0, import_datalog5.lit)("declaresName", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("n"))]
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("n")],
+    [(0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")), (0, import_datalog6.lit)("declaresName", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("n"))]
   ),
   // The method behind each callback the chain registers, by the event
   // that runs it. A base registering one reaches every class below it,
   // and the method may be declared anywhere along the same chain.
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedCallbackMethod",
-    [(0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("event"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held")],
+    [(0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("event"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held")],
     [
-      (0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b")),
-      (0, import_datalog5.lit)("classCallback", (0, import_datalog5.variable)("b"), (0, import_datalog5.variable)("event"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("ancestryChain", (0, import_datalog5.variable)("c"), (0, import_datalog5.variable)("b2")),
-      (0, import_datalog5.lit)("holdsProperty", (0, import_datalog5.variable)("b2"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("held"))
+      (0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b")),
+      (0, import_datalog6.lit)("classCallback", (0, import_datalog6.variable)("b"), (0, import_datalog6.variable)("event"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("ancestryChain", (0, import_datalog6.variable)("c"), (0, import_datalog6.variable)("b2")),
+      (0, import_datalog6.lit)("holdsProperty", (0, import_datalog6.variable)("b2"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("held"))
     ]
   ),
   // The calls behind a receiver, for a pack that wants the anchor a
   // chain hangs off; the README's anchor section says which hops and
   // why the asking side applies the single-answer policy.
-  (0, import_datalog5.rule)("anchorChain", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("wantedAnchor", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("anchorChain", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("wantedAnchor", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)(
     "anchorChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("anchorChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("anchorChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "anchorChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
     [
-      (0, import_datalog5.lit)("anchorChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")),
-      (0, import_datalog5.lit)("moduleExport", (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("z"))
+      (0, import_datalog6.lit)("anchorChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")),
+      (0, import_datalog6.lit)("moduleExport", (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("z"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "anchorChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("c")],
-    [(0, import_datalog5.lit)("anchorChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")), (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("c")],
+    [(0, import_datalog6.lit)("anchorChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")), (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "anchorChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o")],
     [
-      (0, import_datalog5.lit)("anchorChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("readsProperty", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("anchorChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("readsProperty", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedAnchorCall",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")],
-    [(0, import_datalog5.lit)("anchorChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")), (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")],
+    [(0, import_datalog6.lit)("anchorChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")), (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))]
   ),
   ...USES_QUESTIONS,
+  ...SELF_QUESTIONS,
   // Where a value came from, asked from the value. DESIGN.md says why the
   // walk takes `hop`, why it descends into the object a read is off, and
   // why a guard's question stops at a call.
-  (0, import_datalog5.rule)("sourceChain", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("wantedSource", (0, import_datalog5.variable)("x"))]),
+  (0, import_datalog6.rule)("sourceChain", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("wantedSource", (0, import_datalog6.variable)("x"))]),
   ...SOURCE_STEPS.map(
-    (kind) => (0, import_datalog5.rule)(
+    (kind) => (0, import_datalog6.rule)(
       "sourceChain",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-      [(0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("hop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"), kind)]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+      [(0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("hop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"), kind)]
     )
   ),
   ...SOURCE_READS.map(
-    (read) => (0, import_datalog5.rule)(
+    (read) => (0, import_datalog6.rule)(
       "sourceChain",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o")],
-      [(0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), read]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o")],
+      [(0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), read]
     )
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "sourceChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("a")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("a")],
     [
-      (0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("converts", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("converts", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("n"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceConverts",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")),
-      (0, import_datalog5.lit)("converts", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("a"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")),
+      (0, import_datalog6.lit)("converts", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("a"), (0, import_datalog6.variable)("n"))
     ]
   ),
-  (0, import_datalog5.rule)("inputChain", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("x")], [(0, import_datalog5.lit)("wantedInputRead", (0, import_datalog5.variable)("x"))]),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)("inputChain", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("x")], [(0, import_datalog6.lit)("wantedInputRead", (0, import_datalog6.variable)("x"))]),
+  (0, import_datalog6.rule)(
     "inputChain",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("inputChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("inputChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
   ...SOURCE_READS.map(
-    (read) => (0, import_datalog5.rule)(
+    (read) => (0, import_datalog6.rule)(
       "inputChain",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("o")],
-      [(0, import_datalog5.lit)("inputChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), read]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("o")],
+      [(0, import_datalog6.lit)("inputChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), read]
     )
   ),
-  (0, import_datalog5.rule)("sourceMember", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")], [(0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))]),
-  (0, import_datalog5.rule)("sourceMember", [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")], [(0, import_datalog5.lit)("inputChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"))]),
+  (0, import_datalog6.rule)("sourceMember", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")], [(0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))]),
+  (0, import_datalog6.rule)("sourceMember", [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")], [(0, import_datalog6.lit)("inputChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"))]),
   // The chain's steps and what each member is, keyed by the value asked
   // about, so the asking side can rebuild the path a leaf was read along.
   ...SOURCE_STEPS.map(
-    (kind) => (0, import_datalog5.rule)(
+    (kind) => (0, import_datalog6.rule)(
       "wantedSourceHop",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z")],
-      [(0, import_datalog5.lit)("sourceChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("hop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"), kind)]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z")],
+      [(0, import_datalog6.lit)("sourceChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("hop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"), kind)]
     )
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceHop",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z")],
-    [(0, import_datalog5.lit)("inputChain", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), (0, import_datalog5.lit)("nameHop", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("z"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z")],
+    [(0, import_datalog6.lit)("inputChain", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), (0, import_datalog6.lit)("nameHop", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("z"))]
   ),
   ...WRITTEN_KEY_READS.map(
-    (read) => (0, import_datalog5.rule)(
+    (read) => (0, import_datalog6.rule)(
       "wantedSourceRead",
-      [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("n")],
-      [(0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")), read]
+      [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("n")],
+      [(0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")), read]
     )
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceKeyed",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o")],
     [
-      (0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("readsKeyed", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("o"), (0, import_datalog5.variable)("k"))
+      (0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("readsKeyed", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("o"), (0, import_datalog6.variable)("k"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceParam",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("paramOf", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("k"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("paramOf", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("k"), (0, import_datalog6.variable)("p"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceParam",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p"), (0, import_datalog5.variable)("f")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p"), (0, import_datalog6.variable)("f")],
     [
-      (0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("p")),
-      (0, import_datalog5.lit)("paramNamed", (0, import_datalog5.variable)("f"), (0, import_datalog5.variable)("n"), (0, import_datalog5.variable)("p"))
+      (0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("p")),
+      (0, import_datalog6.lit)("paramNamed", (0, import_datalog6.variable)("f"), (0, import_datalog6.variable)("n"), (0, import_datalog6.variable)("p"))
     ]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceWritten",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("w")],
-    [(0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("w")), (0, import_datalog5.lit)("writtenValue", (0, import_datalog5.variable)("w"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("w")],
+    [(0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("w")), (0, import_datalog6.lit)("writtenValue", (0, import_datalog6.variable)("w"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceCall",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")],
-    [(0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("r")), (0, import_datalog5.lit)("call", (0, import_datalog5.variable)("r"), (0, import_datalog5.variable)("c"))]
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")],
+    [(0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("r")), (0, import_datalog6.lit)("call", (0, import_datalog6.variable)("r"), (0, import_datalog6.variable)("c"))]
   ),
-  (0, import_datalog5.rule)(
+  (0, import_datalog6.rule)(
     "wantedSourceImport",
-    [(0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n")],
+    [(0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n")],
     [
-      (0, import_datalog5.lit)("sourceMember", (0, import_datalog5.variable)("x"), (0, import_datalog5.variable)("y")),
-      (0, import_datalog5.lit)("imports", (0, import_datalog5.variable)("y"), (0, import_datalog5.variable)("m"), (0, import_datalog5.variable)("n"))
+      (0, import_datalog6.lit)("sourceMember", (0, import_datalog6.variable)("x"), (0, import_datalog6.variable)("y")),
+      (0, import_datalog6.lit)("imports", (0, import_datalog6.variable)("y"), (0, import_datalog6.variable)("m"), (0, import_datalog6.variable)("n"))
     ]
   )
 ];
@@ -5224,6 +5386,10 @@ var UNDER_ANSWER_RELATIONS = [
   RESOLUTION_QUESTIONS,
   RESOLUTION_RULES,
   RESULT_STEP,
+  SELF_AS_CLASS,
+  SELF_AS_CLASS_NAME,
+  SELF_AS_INSTANCE,
+  SELF_AS_INSTANCE_NAME,
   SPREAD_ENTRY,
   UNDER_ANSWER_RELATIONS,
   UNDER_QUESTION_ROW_BUDGET,
@@ -5263,6 +5429,8 @@ var UNDER_ANSWER_RELATIONS = [
   isObserved,
   isWrittenAsUnder,
   joinMountedPath,
+  keptVariants,
+  memberOf,
   mergeStoredDependencies,
   mountPathsOf,
   noDependencies,
@@ -5272,6 +5440,7 @@ var UNDER_ANSWER_RELATIONS = [
   objectOfUnder,
   observeDemand,
   packHashes,
+  plainKeyOf,
   proofRules,
   queryFacts,
   readDispatchOutcomes,
@@ -5281,6 +5450,8 @@ var UNDER_ANSWER_RELATIONS = [
   resolutionProgram,
   resolutionUnderProgram,
   resolvedFunctions,
+  selfFormOf,
+  selfResultOf,
   settledFunction,
   sourceLeavesOf,
   spanOfKey,
@@ -5290,6 +5461,7 @@ var UNDER_ANSWER_RELATIONS = [
   underQuestionSpend,
   unpackHashes,
   valueLeftByWrites,
+  variantKey,
   walkRecordsByFile,
   writesRunInOrder,
   writtenAnswersFor,