@suss/resolution 0.35.0 → 0.36.0

package/dist/index.js

@@ -27,7 +27,8 @@ var ASKING_RELATIONS = [
   "wantedType",
   "wantedUses",
   "wantedSource",
-  "wantedInputRead"
+  "wantedInputRead",
+  "wantedMembers"
 ];
 var NO_LANGUAGE_RULES = [];
 var programs = /* @__PURE__ */ new WeakMap();
@@ -1952,6 +1953,155 @@ function importedFilesByFile(db, displayPathOf) {
   return byFile;
 }
 
+// src/receiverSelf.ts
+import { constant, lit, rule, variable as v } from "@suss/datalog";
+var MEMBERS_QUESTION = "wantedMembers";
+var SELF_AS_CLASS_NAME = "class";
+var SELF_AS_CLASS = constant(SELF_AS_CLASS_NAME);
+var SELF_AS_INSTANCE_NAME = "instance";
+var SELF_AS_INSTANCE = constant(SELF_AS_INSTANCE_NAME);
+var SELF_RULES = [
+  rule(
+    "selfBehind",
+    [v("s"), v("s"), v("form")],
+    [lit("selfReceiver", v("f"), v("s"), v("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.
+  rule(
+    "selfBehind",
+    [v("x"), v("s"), v("form")],
+    [
+      lit("nameHop", v("x"), v("y")),
+      lit("selfBehind", v("y"), v("s"), v("form"))
+    ],
+    "a name for the receiver"
+  ),
+  // Calling the class makes one of it: Python's `cls(...)` and
+  // TypeScript's `new this(...)`.
+  rule(
+    "selfBehind",
+    [v("r"), v("s"), SELF_AS_INSTANCE],
+    [
+      lit("call", v("r"), v("c")),
+      lit("selfBehind", v("c"), v("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.
+  rule(
+    "selfResult",
+    [v("r"), v("o"), v("form")],
+    [
+      lit("call", v("r"), v("c")),
+      lit("readsProperty", v("c"), v("o"), v("n")),
+      lit("invokes", v("r"), v("f")),
+      lit("returnsValue", v("f"), v("ret")),
+      lit("selfReceiver", v("f"), v("s"), v("any")),
+      lit("selfBehind", v("ret"), v("s"), v("form"))
+    ],
+    "returns its receiver"
+  ),
+  rule(
+    "selfResult",
+    [v("x"), v("o"), v("form")],
+    [
+      lit("nameHop", v("x"), v("y")),
+      lit("selfResult", v("y"), v("o"), v("form"))
+    ],
+    "a name for what it returned"
+  )
+];
+var SELF_QUESTIONS = [
+  rule(
+    "wantedSelfBehind",
+    [v("x"), v("s"), v("form")],
+    [lit("wanted", v("x")), lit("selfBehind", v("x"), v("s"), v("form"))]
+  ),
+  rule(
+    "wantedSelfResult",
+    [v("x"), v("o"), v("form")],
+    [lit("wanted", v("x")), lit("selfResult", v("x"), v("o"), v("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.
+  rule(
+    "wantedMemberOf",
+    [v("cls"), v("n"), v("held")],
+    [
+      lit(MEMBERS_QUESTION, v("cls")),
+      lit("contains", v("cls"), v("n"), v("held"))
+    ]
+  ),
+  rule(
+    "wantedMemberOverridden",
+    [v("cls"), v("n"), v("h")],
+    [
+      lit(MEMBERS_QUESTION, v("cls")),
+      lit("contains", v("cls"), v("n"), v("m")),
+      lit("overrides", v("m"), v("n"), v("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;
@@ -2121,132 +2271,132 @@ function addPackWords(db, words) {
 }
 
 // src/passedOn.ts
-import { lit, rule, variable as v } from "@suss/datalog";
+import { lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
 var USES_QUESTION = "wantedUses";
 var PASSED_ON_RULES = [
-  rule("passedOn", [v("x")], [lit("returnsValue", v("f"), v("x"))], "returned"),
-  rule("passedOn", [v("x")], [lit("yieldsValue", v("f"), v("x"))], "yielded"),
-  rule(
+  rule2("passedOn", [v2("x")], [lit2("returnsValue", v2("f"), v2("x"))], "returned"),
+  rule2("passedOn", [v2("x")], [lit2("yieldsValue", v2("f"), v2("x"))], "yielded"),
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("callArg", v("r"), v("k"), v("x"))],
+    [v2("x")],
+    [lit2("callArg", v2("r"), v2("k"), v2("x"))],
     "an argument"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("callKeywordArg", v("r"), v("k"), v("x"))],
+    [v2("x")],
+    [lit2("callKeywordArg", v2("r"), v2("k"), v2("x"))],
     "a keyword argument"
   ),
-  rule("passedOn", [v("x")], [lit("binds", v("y"), v("x"))], "another name"),
-  rule(
+  rule2("passedOn", [v2("x")], [lit2("binds", v2("y"), v2("x"))], "another name"),
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("endsHolding", v("y"), v("x"))],
+    [v2("x")],
+    [lit2("endsHolding", v2("y"), v2("x"))],
     "another name's last write"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("mayHold", v("y"), v("x"))],
+    [v2("x")],
+    [lit2("mayHold", v2("y"), v2("x"))],
     "one of another name's writes"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("holdsProperty", v("o"), v("n"), v("x"))],
+    [v2("x")],
+    [lit2("holdsProperty", v2("o"), v2("n"), v2("x"))],
     "held by an object"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("storesProperty", v("o"), v("n"), v("x"), v("k"))],
+    [v2("x")],
+    [lit2("storesProperty", v2("o"), v2("n"), v2("x"), v2("k"))],
     "stored on an object"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("holdsUnderKey", v("o"), v("x"))],
+    [v2("x")],
+    [lit2("holdsUnderKey", v2("o"), v2("x"))],
     "stored under a key"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("readsKeyed", v("r"), v("o"), v("x"))],
+    [v2("x")],
+    [lit2("readsKeyed", v2("r"), v2("o"), v2("x"))],
     "used as a key"
   ),
-  rule("passedOn", [v("x")], [lit("entersValue", v("x"))], "entered"),
-  rule(
+  rule2("passedOn", [v2("x")], [lit2("entersValue", v2("x"))], "entered"),
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("entersAs", v("y"), v("x"))],
+    [v2("x")],
+    [lit2("entersAs", v2("y"), v2("x"))],
     "entered under a name"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("paramDefault", v("p"), v("x"))],
+    [v2("x")],
+    [lit2("paramDefault", v2("p"), v2("x"))],
     "a parameter default"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("fallbackBranch", v("e"), v("x"))],
+    [v2("x")],
+    [lit2("fallbackBranch", v2("e"), v2("x"))],
     "a fallback branch"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("conditionalBranch", v("e"), v("x"))],
+    [v2("x")],
+    [lit2("conditionalBranch", v2("e"), v2("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.
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("readsProperty", v("r"), v("x"), v("n")), lit("passedOn", v("r"))],
+    [v2("x")],
+    [lit2("readsProperty", v2("r"), v2("x"), v2("n")), lit2("passedOn", v2("r"))],
     "a property passed on"
   ),
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
-    [lit("readsKeyed", v("r"), v("x"), v("k")), lit("passedOn", v("r"))],
+    [v2("x")],
+    [lit2("readsKeyed", v2("r"), v2("x"), v2("k")), lit2("passedOn", v2("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.
-  rule(
+  rule2(
     "passedOn",
-    [v("x")],
+    [v2("x")],
     [
-      lit("readsProperty", v("r"), v("x"), v("n")),
-      lit("call", v("c"), v("r")),
-      lit("passedOn", v("c"))
+      lit2("readsProperty", v2("r"), v2("x"), v2("n")),
+      lit2("call", v2("c"), v2("r")),
+      lit2("passedOn", v2("c"))
     ],
     "a method result passed on"
   )
 ];
 var USES_QUESTIONS = [
-  rule(
+  rule2(
     "wantedPassedOn",
-    [v("x")],
-    [lit(USES_QUESTION, v("x")), lit("passedOn", v("x"))]
+    [v2("x")],
+    [lit2(USES_QUESTION, v2("x")), lit2("passedOn", v2("x"))]
   ),
-  rule(
+  rule2(
     "wantedPassedOn",
-    [v("x")],
-    [lit(USES_QUESTION, v("x")), lit("call", v("r"), v("x"))]
+    [v2("x")],
+    [lit2(USES_QUESTION, v2("x")), lit2("call", v2("r"), v2("x"))]
   ),
-  rule(
+  rule2(
     "wantedCalledMethod",
-    [v("x"), v("n")],
+    [v2("x"), v2("n")],
     [
-      lit(USES_QUESTION, v("x")),
-      lit("readsProperty", v("r"), v("x"), v("n")),
-      lit("call", v("c"), v("r"))
+      lit2(USES_QUESTION, v2("x")),
+      lit2("readsProperty", v2("r"), v2("x"), v2("n")),
+      lit2("call", v2("c"), v2("r"))
     ]
   )
 ];
@@ -2602,30 +2752,30 @@ function sharedConstruction(writes) {
 }
 
 // src/index.ts
-import { constant, lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
-var VALUE_STEP = constant("value");
+import { constant as constant2, lit as lit3, rule as rule3, variable as v3 } from "@suss/datalog";
+var VALUE_STEP = constant2("value");
 var NAMESPACE_IMPORT_NAME = "*";
-var NAMESPACE_IMPORT = constant(NAMESPACE_IMPORT_NAME);
+var NAMESPACE_IMPORT = constant2(NAMESPACE_IMPORT_NAME);
 var DEFAULT_IMPORT_NAME = "default";
-var DEFAULT_IMPORT = constant(DEFAULT_IMPORT_NAME);
+var DEFAULT_IMPORT = constant2(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 = constant("instance");
+var INSTANCE_STEP = constant2("instance");
 var RECEIVER_STORE_NAME = "receiver";
-var RECEIVER_STORE = constant(RECEIVER_STORE_NAME);
+var RECEIVER_STORE = constant2(RECEIVER_STORE_NAME);
 var NAMED_STORE_NAME = "name";
-var NAMED_STORE = constant(NAMED_STORE_NAME);
+var NAMED_STORE = constant2(NAMED_STORE_NAME);
 var UNPLACED_STORE_NAME = "unplaced";
-var NO_ARGUMENTS = constant("0");
-var FIRST_POSITION = constant("0");
-var THEN_METHOD = constant("then");
-var RESULT_STEP = constant("result");
+var NO_ARGUMENTS = constant2("0");
+var FIRST_POSITION = constant2("0");
+var THEN_METHOD = constant2("then");
+var RESULT_STEP = constant2("result");
 var NO_CONTEXT_NAME = "none";
-var NO_CONTEXT = constant(NO_CONTEXT_NAME);
+var NO_CONTEXT = constant2(NO_CONTEXT_NAME);
 var STEP_LATTICE = [
-  { soFar: VALUE_STEP, next: v2("kind"), took: v2("kind") },
+  { soFar: VALUE_STEP, next: v3("kind"), took: v3("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 },
@@ -2634,1191 +2784,1191 @@ var STEP_LATTICE = [
   { soFar: RESULT_STEP, next: RESULT_STEP, took: RESULT_STEP }
 ];
 var DISPATCH_RULES = [
-  rule2(
+  rule3(
     "entryRead",
-    [v2("site"), v2("o")],
-    [lit2("choosesEntry", v2("site"), v2("o"))]
+    [v3("site"), v3("o")],
+    [lit3("choosesEntry", v3("site"), v3("o"))]
   ),
-  rule2(
+  rule3(
     "entryRead",
-    [v2("site"), v2("o")],
-    [lit2("namedEntryRead", v2("site"), v2("o"), v2("n"))]
+    [v3("site"), v3("o")],
+    [lit3("namedEntryRead", v3("site"), v3("o"), v3("n"))]
   ),
-  rule2(
+  rule3(
     "entryRead",
-    [v2("site"), v2("o")],
-    [lit2("choosesEntryLike", v2("site"), v2("o"), v2("p"), v2("s"))]
+    [v3("site"), v3("o")],
+    [lit3("choosesEntryLike", v3("site"), v3("o"), v3("p"), v3("s"))]
   ),
   // Every entry of a read whose key is partly written out, by name. A rule
   // cannot compare strings, so dispatch.ts keeps the names that match, and
   // these stay out of `dispatchesTo`.
-  rule2(
+  rule3(
     "likeEntryAt",
-    [v2("site"), v2("n"), v2("held")],
+    [v3("site"), v3("n"), v3("held")],
     [
-      lit2("choosesEntryLike", v2("site"), v2("o"), v2("p"), v2("s")),
-      lit2("containerOf", v2("o"), v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("choosesEntryLike", v3("site"), v3("o"), v3("p"), v3("s")),
+      lit3("containerOf", v3("o"), v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("held"))
     ]
   ),
-  rule2(
+  rule3(
     "namedEntryRead",
-    [v2("site"), v2("o"), v2("n")],
-    [lit2("choosesNamedEntry", v2("site"), v2("o"), v2("n"))]
+    [v3("site"), v3("o"), v3("n")],
+    [lit3("choosesNamedEntry", v3("site"), v3("o"), v3("n"))]
   ),
-  rule2(
+  rule3(
     "namedEntryRead",
-    [v2("site"), v2("o"), v2("n")],
-    [lit2("readsEntry", v2("site"), v2("o"), v2("n"))]
+    [v3("site"), v3("o"), v3("n")],
+    [lit3("readsEntry", v3("site"), v3("o"), v3("n"))]
   ),
   // The container a read takes its entry from: an object written out, or
   // a collection the program fills through its methods.
-  rule2("containerOf", [v2("o"), v2("obj")], [lit2("objectOf", v2("o"), v2("obj"))]),
-  rule2(
+  rule3("containerOf", [v3("o"), v3("obj")], [lit3("objectOf", v3("o"), v3("obj"))]),
+  rule3(
     "containerOf",
-    [v2("o"), v2("c")],
+    [v3("o"), v3("c")],
     [
-      lit2("reaches", v2("o"), v2("c"), VALUE_STEP),
-      lit2("collectionValue", v2("c"))
+      lit3("reaches", v3("o"), v3("c"), VALUE_STEP),
+      lit3("collectionValue", v3("c"))
     ]
   ),
-  rule2("containerOf", [v2("c"), v2("c")], [lit2("collectionValue", v2("c"))]),
-  rule2(
+  rule3("containerOf", [v3("c"), v3("c")], [lit3("collectionValue", v3("c"))]),
+  rule3(
     "entryAt",
-    [v2("site"), v2("held")],
+    [v3("site"), v3("held")],
     [
-      lit2("choosesEntry", v2("site"), v2("o")),
-      lit2("containerOf", v2("o"), v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("choosesEntry", v3("site"), v3("o")),
+      lit3("containerOf", v3("o"), v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("held"))
     ],
     "any entry"
   ),
-  rule2(
+  rule3(
     "entryAt",
-    [v2("site"), v2("held")],
+    [v3("site"), v3("held")],
     [
-      lit2("namedEntryRead", v2("site"), v2("o"), v2("n")),
-      lit2("containerOf", v2("o"), v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("namedEntryRead", v3("site"), v3("o"), v3("n")),
+      lit3("containerOf", v3("o"), v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("held"))
     ],
     "named entry"
   ),
-  rule2(
+  rule3(
     "entryAt",
-    [v2("site"), v2("held")],
-    [lit2("computedEntryAt", v2("site"), v2("held"))]
+    [v3("site"), v3("held")],
+    [lit3("computedEntryAt", v3("site"), v3("held"))]
   ),
   // A write under a key the source computes, `T[name] = fn` or a map's
   // `set`, could be under any name, so every read of the container may
   // come back with it, a read narrowed to one name included.
-  rule2(
+  rule3(
     "computedEntryAt",
-    [v2("site"), v2("held")],
+    [v3("site"), v3("held")],
     [
-      lit2("entryRead", v2("site"), v2("o")),
-      lit2("containerOf", v2("o"), v2("c")),
-      lit2("refersToObject", v2("x"), v2("c")),
-      lit2("holdsUnderKey", v2("x"), v2("held"))
+      lit3("entryRead", v3("site"), v3("o")),
+      lit3("containerOf", v3("o"), v3("c")),
+      lit3("refersToObject", v3("x"), v3("c")),
+      lit3("holdsUnderKey", v3("x"), v3("held"))
     ],
     "entry under a computed key"
   ),
   // The read a call takes its function from: the callee itself, a name
   // for it, or the call when the call is the read, as Ruby's `send` is.
-  rule2(
+  rule3(
     "callsEntryAt",
-    [v2("r"), v2("site")],
-    [lit2("call", v2("r"), v2("site")), lit2("entryRead", v2("site"), v2("o"))]
+    [v3("r"), v3("site")],
+    [lit3("call", v3("r"), v3("site")), lit3("entryRead", v3("site"), v3("o"))]
   ),
-  rule2(
+  rule3(
     "callsEntryAt",
-    [v2("r"), v2("site")],
+    [v3("r"), v3("site")],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("reaches", v2("c"), v2("site"), VALUE_STEP),
-      lit2("entryRead", v2("site"), v2("o"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("reaches", v3("c"), v3("site"), VALUE_STEP),
+      lit3("entryRead", v3("site"), v3("o"))
     ]
   ),
-  rule2("callsEntryAt", [v2("r"), v2("r")], [lit2("callsChosenEntry", v2("r"))]),
-  rule2(
+  rule3("callsEntryAt", [v3("r"), v3("r")], [lit3("callsChosenEntry", v3("r"))]),
+  rule3(
     "callsEntryAt",
-    [v2("r"), v2("site")],
-    [lit2("callsEntryInBranch", v2("r"), v2("site"))]
+    [v3("r"), v3("site")],
+    [lit3("callsEntryInBranch", v3("r"), v3("site"))]
   ),
   // `c ? T[k] : undefined` is one of its branches, so a call through it
   // may run what the read gives. The other branch may be some other
   // function, so dispatch.ts never counts such a call as certain.
-  rule2(
+  rule3(
     "callsEntryInBranch",
-    [v2("r"), v2("site")],
-    [lit2("call", v2("r"), v2("c")), lit2("branchReadsEntry", v2("c"), v2("site"))]
+    [v3("r"), v3("site")],
+    [lit3("call", v3("r"), v3("c")), lit3("branchReadsEntry", v3("c"), v3("site"))]
   ),
-  rule2(
+  rule3(
     "callsEntryInBranch",
-    [v2("r"), v2("site")],
+    [v3("r"), v3("site")],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("reaches", v2("c"), v2("x"), VALUE_STEP),
-      lit2("branchReadsEntry", v2("x"), v2("site"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("reaches", v3("c"), v3("x"), VALUE_STEP),
+      lit3("branchReadsEntry", v3("x"), v3("site"))
     ]
   ),
-  rule2(
+  rule3(
     "branchReadsEntry",
-    [v2("x"), v2("site")],
+    [v3("x"), v3("site")],
     [
-      lit2("conditionalBranch", v2("x"), v2("site")),
-      lit2("entryRead", v2("site"), v2("o"))
+      lit3("conditionalBranch", v3("x"), v3("site")),
+      lit3("entryRead", v3("site"), v3("o"))
     ]
   ),
-  rule2(
+  rule3(
     "branchReadsEntry",
-    [v2("x"), v2("site")],
+    [v3("x"), v3("site")],
     [
-      lit2("conditionalBranch", v2("x"), v2("b")),
-      lit2("reaches", v2("b"), v2("site"), VALUE_STEP),
-      lit2("entryRead", v2("site"), v2("o"))
+      lit3("conditionalBranch", v3("x"), v3("b")),
+      lit3("reaches", v3("b"), v3("site"), VALUE_STEP),
+      lit3("entryRead", v3("site"), v3("o"))
     ]
   ),
-  rule2(
+  rule3(
     "dispatchesTo",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("entryAt", v2("site"), v2("held")),
-      lit2("comesTo", v2("held"), v2("f")),
-      lit2("func", v2("f"))
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("entryAt", v3("site"), v3("held")),
+      lit3("comesTo", v3("held"), v3("f")),
+      lit3("func", v3("f"))
     ]
   ),
   // A collection a program fills is an object the way a written one is,
   // so a write through a name for it lands on it.
-  rule2("refersToObject", [v2("c"), v2("c")], [lit2("collectionValue", v2("c"))])
+  rule3("refersToObject", [v3("c"), v3("c")], [lit3("collectionValue", v3("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.
-  rule2("nameHop", [v2("x"), v2("y")], [lit2("binds", v2("x"), v2("y"))], "alias"),
+  rule3("nameHop", [v3("x"), v3("y")], [lit3("binds", v3("x"), v3("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.
-  rule2(
+  rule3(
     "nameHop",
-    [v2("x"), v2("y")],
-    [lit2("endsHolding", v2("x"), v2("y"))],
+    [v3("x"), v3("y")],
+    [lit3("endsHolding", v3("x"), v3("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.
-  rule2(
+  rule3(
     "nameHop",
-    [v2("x"), v2("y")],
-    [lit2("mayHold", v2("x"), v2("y")), lit2("writesAllStated", v2("x"))],
+    [v3("x"), v3("y")],
+    [lit3("mayHold", v3("x"), v3("y")), lit3("writesAllStated", v3("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.
-  rule2(
+  rule3(
     "nameHop",
-    [v2("x"), v2("b")],
-    [lit2("fallbackBranch", v2("x"), v2("b"))],
+    [v3("x"), v3("b")],
+    [lit3("fallbackBranch", v3("x"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("x"), v2("y"), VALUE_STEP],
-    [lit2("nameHop", v2("x"), v2("y"))],
+    [v3("x"), v3("y"), VALUE_STEP],
+    [lit3("nameHop", v3("x"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("x"), v2("value"), VALUE_STEP],
+    [v3("x"), v3("value"), VALUE_STEP],
     [
-      lit2("imports", v2("x"), v2("m"), v2("n")),
-      lit2("moduleExport", v2("m"), v2("n"), v2("value"))
+      lit3("imports", v3("x"), v3("m"), v3("n")),
+      lit3("moduleExport", v3("m"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "stepsTo",
-    [v2("p"), v2("a"), VALUE_STEP],
-    [lit2("passesArgument", v2("r"), v2("p"), v2("a"))],
+    [v3("p"), v3("a"), VALUE_STEP],
+    [lit3("passesArgument", v3("r"), v3("p"), v3("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.
-  rule2(
+  rule3(
     "stepsTo",
-    [v2("x"), v2("held"), VALUE_STEP],
+    [v3("x"), v3("held"), VALUE_STEP],
     [
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("objectOf", v2("o"), v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("objectOf", v3("o"), v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("cls"), INSTANCE_STEP],
+    [v3("r"), v3("cls"), INSTANCE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesTo", v2("c"), v2("cls")),
-      lit2("objectValue", v2("cls"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesTo", v3("c"), v3("cls")),
+      lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("x"), v2("cls"), INSTANCE_STEP],
-    [lit2("instanceOf", v2("x"), v2("cls"))],
+    [v3("x"), v3("cls"), INSTANCE_STEP],
+    [lit3("instanceOf", v3("x"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("cls"), INSTANCE_STEP],
+    [v3("r"), v3("cls"), INSTANCE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("readsProperty", v2("c"), v2("o"), v2("m")),
-      lit2("objectOf", v2("o"), v2("cls")),
-      lit2("objectValue", v2("cls")),
+      lit3("call", v3("r"), v3("c")),
+      lit3("readsProperty", v3("c"), v3("o"), v3("m")),
+      lit3("objectOf", v3("o"), v3("cls")),
+      lit3("objectValue", v3("cls")),
       // Before `libraryBase`, so the demand rewrite asks it with the base
       // bound and walks an ancestry only for a method a pack declared.
-      lit2("givesBackOne", v2("n"), v2("m")),
-      lit2("libraryBase", v2("cls"), v2("n"))
+      lit3("givesBackOne", v3("n"), v3("m")),
+      lit3("libraryBase", v3("cls"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("cls"), INSTANCE_STEP],
+    [v3("r"), v3("cls"), INSTANCE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("readsProperty", v2("c"), v2("o"), v2("m")),
-      lit2("callArg", v2("r"), v2("k"), v2("a")),
+      lit3("call", v3("r"), v3("c")),
+      lit3("readsProperty", v3("c"), v3("o"), v3("m")),
+      lit3("callArg", v3("r"), v3("k"), v3("a")),
       // Before `libraryBase`, so the demand rewrite asks it with the base
       // bound and walks an ancestry only for a method a pack declared.
-      lit2("givesBackOneOfArgument", v2("n"), v2("m"), v2("k")),
-      lit2("objectOf", v2("a"), v2("cls")),
-      lit2("libraryBase", v2("cls"), v2("n"))
+      lit3("givesBackOneOfArgument", v3("n"), v3("m"), v3("k")),
+      lit3("objectOf", v3("a"), v3("cls")),
+      lit3("libraryBase", v3("cls"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("cls"), INSTANCE_STEP],
+    [v3("r"), v3("cls"), INSTANCE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("mod"), v2("n")),
-      lit2("givesBackOneOfImport", v2("mod"), v2("n"), v2("k")),
-      lit2("callArg", v2("r"), v2("k"), v2("a")),
-      lit2("objectOf", v2("a"), v2("cls"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("mod"), v3("n")),
+      lit3("givesBackOneOfImport", v3("mod"), v3("n"), v3("k")),
+      lit3("callArg", v3("r"), v3("k"), v3("a")),
+      lit3("objectOf", v3("a"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("y"), v2("r"), VALUE_STEP],
+    [v3("y"), v3("r"), VALUE_STEP],
     [
-      lit2("entersAs", v2("y"), v2("r")),
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("mod"), v2("n")),
-      lit2("entersAsSelf", v2("mod"), v2("n"))
+      lit3("entersAs", v3("y"), v3("r")),
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("mod"), v3("n")),
+      lit3("entersAsSelf", v3("mod"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("o"), VALUE_STEP],
+    [v3("r"), v3("o"), VALUE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("readsProperty", v2("c"), v2("o"), v2("m")),
-      lit2("returnsReceiver", v2("m"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("readsProperty", v3("c"), v3("o"), v3("m")),
+      lit3("returnsReceiver", v3("m"))
     ],
     "returns its receiver"
   ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("a"), VALUE_STEP],
+    [v3("r"), v3("a"), VALUE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesTo", v2("c"), v2("f")),
-      lit2("unwraps", v2("f"), v2("k")),
-      lit2("callArg", v2("r"), v2("k"), v2("a"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesTo", v3("c"), v3("f")),
+      lit3("unwraps", v3("f"), v3("k")),
+      lit3("callArg", v3("r"), v3("k"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("a"), VALUE_STEP],
+    [v3("r"), v3("a"), VALUE_STEP],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("m"), v2("n")),
-      lit2("unwrapsByName", v2("m"), v2("n"), v2("k")),
-      lit2("callArg", v2("r"), v2("k"), v2("a")),
-      lit2("describesValue", v2("a"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("m"), v3("n")),
+      lit3("unwrapsByName", v3("m"), v3("n"), v3("k")),
+      lit3("callArg", v3("r"), v3("k"), v3("a")),
+      lit3("describesValue", v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("p"), v2("d"), VALUE_STEP],
+    [v3("p"), v3("d"), VALUE_STEP],
     [
-      lit2("decoratedWith", v2("p"), v2("d")),
-      lit2("call", v2("d"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("m"), v2("n")),
-      lit2("suppliesParameter", v2("m"), v2("n"))
+      lit3("decoratedWith", v3("p"), v3("d")),
+      lit3("call", v3("d"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("m"), v3("n")),
+      lit3("suppliesParameter", v3("m"), v3("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.
   ...[
-    lit2("func", v2("a")),
-    lit2("writtenValue", v2("a")),
-    lit2("holdsProperty", v2("a"), v2("p"), v2("x")),
-    lit2("imports", v2("a"), v2("m"), v2("n")),
-    lit2("stepsTo", v2("a"), v2("y"), v2("kind"))
-  ].map((kind) => rule2("describesValue", [v2("a")], [kind])),
+    lit3("func", v3("a")),
+    lit3("writtenValue", v3("a")),
+    lit3("holdsProperty", v3("a"), v3("p"), v3("x")),
+    lit3("imports", v3("a"), v3("m"), v3("n")),
+    lit3("stepsTo", v3("a"), v3("y"), v3("kind"))
+  ].map((kind) => rule3("describesValue", [v3("a")], [kind])),
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("ret"), RESULT_STEP],
-    [lit2("invokes", v2("r"), v2("f")), lit2("returnsValue", v2("f"), v2("ret"))],
+    [v3("r"), v3("ret"), RESULT_STEP],
+    [lit3("invokes", v3("r"), v3("f")), lit3("returnsValue", v3("f"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("p"), v2("r"), VALUE_STEP],
+    [v3("p"), v3("r"), VALUE_STEP],
     [
-      lit2("paramOf", v2("cb"), FIRST_POSITION, v2("p")),
-      lit2("callArg", v2("t"), FIRST_POSITION, v2("cb")),
-      lit2("call", v2("t"), v2("m")),
-      lit2("readsProperty", v2("m"), v2("r"), THEN_METHOD)
+      lit3("paramOf", v3("cb"), FIRST_POSITION, v3("p")),
+      lit3("callArg", v3("t"), FIRST_POSITION, v3("cb")),
+      lit3("call", v3("t"), v3("m")),
+      lit3("readsProperty", v3("m"), v3("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.
-  rule2(
+  rule3(
     "hop",
-    [v2("r"), v2("cls"), RESULT_STEP],
+    [v3("r"), v3("cls"), RESULT_STEP],
     [
-      lit2("invokes", v2("r"), v2("f")),
-      lit2("returnsClass", v2("f"), v2("x")),
-      lit2("comesTo", v2("x"), v2("cls")),
-      lit2("objectValue", v2("cls"))
+      lit3("invokes", v3("r"), v3("f")),
+      lit3("returnsClass", v3("f"), v3("x")),
+      lit3("comesTo", v3("x"), v3("cls")),
+      lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "reaches",
-    [v2("x"), v2("z"), v2("kind")],
-    [lit2("stepsTo", v2("x"), v2("z"), v2("kind"))]
+    [v3("x"), v3("z"), v3("kind")],
+    [lit3("stepsTo", v3("x"), v3("z"), v3("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 }) => rule2(
+    ({ soFar, next, took }) => rule3(
       "reaches",
-      [v2("x"), v2("z"), took],
+      [v3("x"), v3("z"), took],
       [
-        lit2("reaches", v2("x"), v2("y"), soFar),
-        lit2("stepsTo", v2("y"), v2("z"), next)
+        lit3("reaches", v3("x"), v3("y"), soFar),
+        lit3("stepsTo", v3("y"), v3("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.
-  rule2("context", [NO_CONTEXT], [], "no context"),
-  rule2(
+  rule3("context", [NO_CONTEXT], [], "no context"),
+  rule3(
     "context",
-    [v2("site")],
-    [lit2("allocates", v2("site"), v2("cls"))],
+    [v3("site")],
+    [lit3("allocates", v3("site"), v3("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.
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("z"), v2("c"), v2("kind")],
-    [lit2("context", v2("c")), lit2("hop", v2("x"), v2("z"), v2("kind"))],
+    [v3("x"), v3("c"), v3("z"), v3("c"), v3("kind")],
+    [lit3("context", v3("c")), lit3("hop", v3("x"), v3("z"), v3("kind"))],
     "under one hop"
   ),
   ...STEP_LATTICE.map(
-    ({ soFar, next, took }) => rule2(
+    ({ soFar, next, took }) => rule3(
       "reachesUnder",
-      [v2("x"), v2("c"), v2("z"), v2("c2"), took],
+      [v3("x"), v3("c"), v3("z"), v3("c2"), took],
       [
-        lit2("reachesUnder", v2("x"), v2("c"), v2("y"), v2("c2"), soFar),
-        lit2("hop", v2("y"), v2("z"), next)
+        lit3("reachesUnder", v3("x"), v3("c"), v3("y"), v3("c2"), soFar),
+        lit3("hop", v3("y"), v3("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.
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("c"), v2("c"), VALUE_STEP],
-    [lit2("instanceOf", v2("x"), v2("cls")), lit2("allocates", v2("c"), v2("cls"))],
+    [v3("x"), v3("c"), v3("c"), v3("c"), VALUE_STEP],
+    [lit3("instanceOf", v3("x"), v3("cls")), lit3("allocates", v3("c"), v3("cls"))],
     "receiver is the site"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("c2"), v2("c2"), v2("kind")],
+    [v3("x"), v3("c"), v3("c2"), v3("c2"), v3("kind")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("y"), v2("c2"), v2("kind")),
-      lit2("instanceOf", v2("y"), v2("cls")),
-      lit2("allocates", v2("c2"), v2("cls"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("y"), v3("c2"), v3("kind")),
+      lit3("instanceOf", v3("y"), v3("cls")),
+      lit3("allocates", v3("c2"), v3("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.
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("site"), v2("c"), v2("site")],
-    [lit2("context", v2("c")), lit2("allocates", v2("site"), v2("cls"))],
+    [v3("site"), v3("c"), v3("site")],
+    [lit3("context", v3("c")), lit3("allocates", v3("site"), v3("cls"))],
     "site is its own object"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), v2("c"), v2("site")],
+    [v3("o"), v3("c"), v3("site")],
     [
-      lit2("reachesUnder", v2("o"), v2("c"), v2("site"), v2("c2"), VALUE_STEP),
-      lit2("allocates", v2("site"), v2("cls"))
+      lit3("reachesUnder", v3("o"), v3("c"), v3("site"), v3("c2"), VALUE_STEP),
+      lit3("allocates", v3("site"), v3("cls"))
     ],
     "name of a site"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), v2("c"), v2("obj")],
+    [v3("o"), v3("c"), v3("obj")],
     [
-      lit2("reachesUnder", v2("o"), v2("c"), v2("obj"), v2("c2"), VALUE_STEP),
-      lit2("objectValue", v2("obj"))
+      lit3("reachesUnder", v3("o"), v3("c"), v3("obj"), v3("c2"), VALUE_STEP),
+      lit3("objectValue", v3("obj"))
     ],
     "written object under a context"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), v2("c"), v2("obj")],
+    [v3("o"), v3("c"), v3("obj")],
     [
-      lit2("reachesUnder", v2("o"), v2("c"), v2("obj"), v2("c2"), RESULT_STEP),
-      lit2("objectValue", v2("obj"))
+      lit3("reachesUnder", v3("o"), v3("c"), v3("obj"), v3("c2"), RESULT_STEP),
+      lit3("objectValue", v3("obj"))
     ],
     "returned object under a context"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), NO_CONTEXT, v2("cls")],
+    [v3("o"), NO_CONTEXT, v3("cls")],
     [
-      lit2(
+      lit3(
         "reachesUnder",
-        v2("o"),
+        v3("o"),
         NO_CONTEXT,
-        v2("cls"),
+        v3("cls"),
         NO_CONTEXT,
         INSTANCE_STEP
       ),
-      lit2("objectValue", v2("cls"))
+      lit3("objectValue", v3("cls"))
     ],
     "class reached with no context"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), NO_CONTEXT, v2("cls")],
-    [lit2("instanceOf", v2("o"), v2("cls"))],
+    [v3("o"), NO_CONTEXT, v3("cls")],
+    [lit3("instanceOf", v3("o"), v3("cls"))],
     "receiver class with no context"
   ),
-  rule2(
+  rule3(
     "objectOfUnder",
-    [v2("o"), v2("c"), v2("o")],
-    [lit2("context", v2("c")), lit2("objectValue", v2("o"))],
+    [v3("o"), v3("c"), v3("o")],
+    [lit3("context", v3("c")), lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("held"), v2("site"), VALUE_STEP],
+    [v3("x"), v3("c"), v3("held"), v3("site"), VALUE_STEP],
     [
-      lit2("context", v2("c")),
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("objectOfUnder", v2("o"), v2("c"), v2("site")),
-      lit2("allocates", v2("site"), v2("cls")),
-      lit2("contains", v2("site"), v2("n"), v2("held"))
+      lit3("context", v3("c")),
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("objectOfUnder", v3("o"), v3("c"), v3("site")),
+      lit3("allocates", v3("site"), v3("cls")),
+      lit3("contains", v3("site"), v3("n"), v3("held"))
     ],
     "property read at a site"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("held"), v2("c"), VALUE_STEP],
+    [v3("x"), v3("c"), v3("held"), v3("c"), VALUE_STEP],
     [
-      lit2("context", v2("c")),
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("objectOfUnder", v2("o"), v2("c"), v2("obj")),
-      lit2("objectValue", v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("context", v3("c")),
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("objectOfUnder", v3("o"), v3("c"), v3("obj")),
+      lit3("objectValue", v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("held"))
     ],
     "property read off an object"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("held"), v2("site"), v2("kind")],
+    [v3("x"), v3("c"), v3("held"), v3("site"), v3("kind")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("y"), v2("c2"), v2("kind")),
-      lit2("readsProperty", v2("y"), v2("o"), v2("n")),
-      lit2("objectOfUnder", v2("o"), v2("c2"), v2("site")),
-      lit2("allocates", v2("site"), v2("cls")),
-      lit2("contains", v2("site"), v2("n"), v2("held"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("y"), v3("c2"), v3("kind")),
+      lit3("readsProperty", v3("y"), v3("o"), v3("n")),
+      lit3("objectOfUnder", v3("o"), v3("c2"), v3("site")),
+      lit3("allocates", v3("site"), v3("cls")),
+      lit3("contains", v3("site"), v3("n"), v3("held"))
     ],
     "reached property read at a site"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("held"), v2("c2"), v2("kind")],
+    [v3("x"), v3("c"), v3("held"), v3("c2"), v3("kind")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("y"), v2("c2"), v2("kind")),
-      lit2("readsProperty", v2("y"), v2("o"), v2("n")),
-      lit2("objectOfUnder", v2("o"), v2("c2"), v2("obj")),
-      lit2("objectValue", v2("obj")),
-      lit2("contains", v2("obj"), v2("n"), v2("held"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("y"), v3("c2"), v3("kind")),
+      lit3("readsProperty", v3("y"), v3("o"), v3("n")),
+      lit3("objectOfUnder", v3("o"), v3("c2"), v3("obj")),
+      lit3("objectValue", v3("obj")),
+      lit3("contains", v3("obj"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("p"), v2("c"), v2("a"), v2("c3"), VALUE_STEP],
+    [v3("p"), v3("c"), v3("a"), v3("c3"), VALUE_STEP],
     [
-      lit2("context", v2("c")),
-      lit2("paramOf", v2("f"), v2("i"), v2("p")),
-      lit2("entersUnder", v2("r"), v2("f"), v2("c"), v2("c3")),
-      lit2("callArg", v2("r"), v2("i"), v2("a"))
+      lit3("context", v3("c")),
+      lit3("paramOf", v3("f"), v3("i"), v3("p")),
+      lit3("entersUnder", v3("r"), v3("f"), v3("c"), v3("c3")),
+      lit3("callArg", v3("r"), v3("i"), v3("a"))
     ],
     "argument under a context"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("p"), v2("c"), v2("a"), v2("c3"), VALUE_STEP],
+    [v3("p"), v3("c"), v3("a"), v3("c3"), VALUE_STEP],
     [
-      lit2("context", v2("c")),
-      lit2("paramNamed", v2("f"), v2("n"), v2("p")),
-      lit2("entersUnder", v2("r"), v2("f"), v2("c"), v2("c3")),
-      lit2("callKeywordArg", v2("r"), v2("n"), v2("a"))
+      lit3("context", v3("c")),
+      lit3("paramNamed", v3("f"), v3("n"), v3("p")),
+      lit3("entersUnder", v3("r"), v3("f"), v3("c"), v3("c3")),
+      lit3("callKeywordArg", v3("r"), v3("n"), v3("a"))
     ],
     "keyword argument under a context"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("a"), v2("c3"), v2("kind")],
+    [v3("x"), v3("c"), v3("a"), v3("c3"), v3("kind")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("p"), v2("c2"), v2("kind")),
-      lit2("paramOf", v2("f"), v2("i"), v2("p")),
-      lit2("entersUnder", v2("r"), v2("f"), v2("c2"), v2("c3")),
-      lit2("callArg", v2("r"), v2("i"), v2("a"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("p"), v3("c2"), v3("kind")),
+      lit3("paramOf", v3("f"), v3("i"), v3("p")),
+      lit3("entersUnder", v3("r"), v3("f"), v3("c2"), v3("c3")),
+      lit3("callArg", v3("r"), v3("i"), v3("a"))
     ],
     "reached argument under a context"
   ),
-  rule2(
+  rule3(
     "reachesUnder",
-    [v2("x"), v2("c"), v2("a"), v2("c3"), v2("kind")],
+    [v3("x"), v3("c"), v3("a"), v3("c3"), v3("kind")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("p"), v2("c2"), v2("kind")),
-      lit2("paramNamed", v2("f"), v2("n"), v2("p")),
-      lit2("entersUnder", v2("r"), v2("f"), v2("c2"), v2("c3")),
-      lit2("callKeywordArg", v2("r"), v2("n"), v2("a"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("p"), v3("c2"), v3("kind")),
+      lit3("paramNamed", v3("f"), v3("n"), v3("p")),
+      lit3("entersUnder", v3("r"), v3("f"), v3("c2"), v3("c3")),
+      lit3("callKeywordArg", v3("r"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "entersUnder",
-    [v2("site"), v2("ctor"), v2("site"), v2("caller")],
+    [v3("site"), v3("ctor"), v3("site"), v3("caller")],
     [
-      lit2("allocates", v2("site"), v2("cls")),
-      lit2("runsConstructor", v2("cls"), v2("ctor")),
-      lit2("callUnder", v2("site"), v2("caller"))
+      lit3("allocates", v3("site"), v3("cls")),
+      lit3("runsConstructor", v3("cls"), v3("ctor")),
+      lit3("callUnder", v3("site"), v3("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.
-  rule2(
+  rule3(
     "entersUnder",
-    [v2("r"), v2("f"), v2("site"), v2("caller")],
+    [v3("r"), v3("f"), v3("site"), v3("caller")],
     [
-      lit2("methodCallUnder", v2("r"), v2("o"), v2("m"), v2("caller")),
-      lit2("objectOfUnder", v2("o"), v2("caller"), v2("site")),
-      lit2("allocates", v2("site"), v2("cls")),
-      lit2("contains", v2("site"), v2("m"), v2("f"))
+      lit3("methodCallUnder", v3("r"), v3("o"), v3("m"), v3("caller")),
+      lit3("objectOfUnder", v3("o"), v3("caller"), v3("site")),
+      lit3("allocates", v3("site"), v3("cls")),
+      lit3("contains", v3("site"), v3("m"), v3("f"))
     ],
     "method call enters under its receiver"
   ),
-  rule2(
+  rule3(
     "methodCallUnder",
-    [v2("r"), v2("o"), v2("m"), v2("caller")],
+    [v3("r"), v3("o"), v3("m"), v3("caller")],
     [
-      lit2("call", v2("r"), v2("cal")),
-      lit2("readsProperty", v2("cal"), v2("o"), v2("m")),
-      lit2("callUnder", v2("r"), v2("caller"))
+      lit3("call", v3("r"), v3("cal")),
+      lit3("readsProperty", v3("cal"), v3("o"), v3("m")),
+      lit3("callUnder", v3("r"), v3("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.
-  rule2(
+  rule3(
     "entersUnder",
-    [v2("r"), v2("f"), v2("c"), v2("c")],
+    [v3("r"), v3("f"), v3("c"), v3("c")],
     [
-      lit2("context", v2("c")),
-      lit2("callsNamed", v2("r"), v2("f")),
-      lit2("callUnder", v2("r"), v2("c"))
+      lit3("context", v3("c")),
+      lit3("callsNamed", v3("r"), v3("f")),
+      lit3("callUnder", v3("r"), v3("c"))
     ],
     "named call enters under the site it is made in"
   ),
-  rule2(
+  rule3(
     "entersUnder",
-    [v2("r"), v2("f"), NO_CONTEXT, v2("caller")],
+    [v3("r"), v3("f"), NO_CONTEXT, v3("caller")],
     [
-      lit2("callsFunction", v2("r"), v2("f")),
-      lit2("callUnder", v2("r"), v2("caller"))
+      lit3("callsFunction", v3("r"), v3("f")),
+      lit3("callUnder", v3("r"), v3("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.
-  rule2(
+  rule3(
     "runsConstructor",
-    [v2("cls"), v2("f")],
-    [lit2("initializes", v2("cls"), v2("f"))]
+    [v3("cls"), v3("f")],
+    [lit3("initializes", v3("cls"), v3("f"))]
   ),
-  rule2(
+  rule3(
     "runsConstructor",
-    [v2("cls"), v2("f")],
+    [v3("cls"), v3("f")],
     [
-      lit2("extends", v2("cls"), v2("b")),
-      lit2("comesTo", v2("b"), v2("base")),
-      lit2("runsConstructor", v2("base"), v2("f"))
+      lit3("extends", v3("cls"), v3("b")),
+      lit3("comesTo", v3("b"), v3("base")),
+      lit3("runsConstructor", v3("base"), v3("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.
-  rule2("callInBody", [v2("f"), v2("r")], [lit2("makesCall", v2("f"), v2("r"))]),
-  rule2(
+  rule3("callInBody", [v3("f"), v3("r")], [lit3("makesCall", v3("f"), v3("r"))]),
+  rule3(
     "callInBody",
-    [v2("f"), v2("r")],
-    [lit2("containsFn", v2("f"), v2("g")), lit2("callInBody", v2("g"), v2("r"))]
+    [v3("f"), v3("r")],
+    [lit3("containsFn", v3("f"), v3("g")), lit3("callInBody", v3("g"), v3("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.
-  rule2(
+  rule3(
     "callUnder",
-    [v2("r"), v2("site")],
+    [v3("r"), v3("site")],
     [
-      lit2("callInBody", v2("f"), v2("r")),
-      lit2("holdsProperty", v2("cls"), v2("m"), v2("f")),
-      lit2("allocates", v2("site"), v2("cls"))
+      lit3("callInBody", v3("f"), v3("r")),
+      lit3("holdsProperty", v3("cls"), v3("m"), v3("f")),
+      lit3("allocates", v3("site"), v3("cls"))
     ],
     "call in a method"
   ),
-  rule2(
+  rule3(
     "callUnder",
-    [v2("r"), v2("site")],
+    [v3("r"), v3("site")],
     [
-      lit2("callInBody", v2("f"), v2("r")),
-      lit2("initializes", v2("cls"), v2("f")),
-      lit2("allocates", v2("site"), v2("cls"))
+      lit3("callInBody", v3("f"), v3("r")),
+      lit3("initializes", v3("cls"), v3("f")),
+      lit3("allocates", v3("site"), v3("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.
-  rule2(
+  rule3(
     "callUnder",
-    [v2("r"), v2("c")],
+    [v3("r"), v3("c")],
     [
-      lit2("callOutsideMethod", v2("r")),
-      lit2("callInBody", v2("f"), v2("r")),
-      lit2("entersUnder", v2("into"), v2("f"), v2("c"), v2("c4"))
+      lit3("callOutsideMethod", v3("r")),
+      lit3("callInBody", v3("f"), v3("r")),
+      lit3("entersUnder", v3("into"), v3("f"), v3("c"), v3("c4"))
     ],
     "call in a function entered under a site"
   ),
-  rule2(
+  rule3(
     "callUnder",
-    [v2("r"), NO_CONTEXT],
-    [lit2("callOutsideMethod", v2("r"))],
+    [v3("r"), NO_CONTEXT],
+    [lit3("callOutsideMethod", v3("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.
-  rule2(
+  rule3(
     "isWrittenAsUnder",
-    [v2("x"), v2("c"), v2("x")],
-    [lit2("context", v2("c")), lit2("writtenValue", v2("x"))]
+    [v3("x"), v3("c"), v3("x")],
+    [lit3("context", v3("c")), lit3("writtenValue", v3("x"))]
   ),
-  rule2(
+  rule3(
     "isWrittenAsUnder",
-    [v2("x"), v2("c"), v2("x")],
-    [lit2("context", v2("c")), lit2("objectValue", v2("x"))]
+    [v3("x"), v3("c"), v3("x")],
+    [lit3("context", v3("c")), lit3("objectValue", v3("x"))]
   ),
-  rule2(
+  rule3(
     "isWrittenAsUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), VALUE_STEP),
-      lit2("writtenValue", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), VALUE_STEP),
+      lit3("writtenValue", v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "isWrittenAsUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), VALUE_STEP),
-      lit2("objectValue", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), VALUE_STEP),
+      lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "fallbackBehindUnder",
-    [v2("x"), v2("c"), v2("x")],
-    [lit2("context", v2("c")), lit2("fallbackBranch", v2("x"), v2("b"))]
+    [v3("x"), v3("c"), v3("x")],
+    [lit3("context", v3("c")), lit3("fallbackBranch", v3("x"), v3("b"))]
   ),
-  rule2(
+  rule3(
     "fallbackBehindUnder",
-    [v2("x"), v2("c"), v2("f")],
+    [v3("x"), v3("c"), v3("f")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("f"), v2("c2"), VALUE_STEP),
-      lit2("fallbackBranch", v2("f"), v2("b"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("f"), v3("c2"), VALUE_STEP),
+      lit3("fallbackBranch", v3("f"), v3("b"))
     ]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("x")],
-    [lit2("context", v2("c")), lit2("func", v2("x"))]
+    [v3("x"), v3("c"), v3("x")],
+    [lit3("context", v3("c")), lit3("func", v3("x"))]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("x")],
-    [lit2("context", v2("c")), lit2("objectValue", v2("x"))]
+    [v3("x"), v3("c"), v3("x")],
+    [lit3("context", v3("c")), lit3("objectValue", v3("x"))]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), VALUE_STEP),
-      lit2("func", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), VALUE_STEP),
+      lit3("func", v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), VALUE_STEP),
-      lit2("objectValue", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), VALUE_STEP),
+      lit3("objectValue", v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), INSTANCE_STEP),
-      lit2("func", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), INSTANCE_STEP),
+      lit3("func", v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "comesToUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("reachesUnder", v2("x"), v2("c"), v2("z"), v2("c2"), INSTANCE_STEP),
-      lit2("objectValue", v2("z"))
+      lit3("reachesUnder", v3("x"), v3("c"), v3("z"), v3("c2"), INSTANCE_STEP),
+      lit3("objectValue", v3("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.
-  rule2("comesTo", [v2("x"), v2("x")], [lit2("func", v2("x"))]),
-  rule2("comesTo", [v2("x"), v2("x")], [lit2("objectValue", v2("x"))]),
-  rule2(
+  rule3("comesTo", [v3("x"), v3("x")], [lit3("func", v3("x"))]),
+  rule3("comesTo", [v3("x"), v3("x")], [lit3("objectValue", v3("x"))]),
+  rule3(
     "comesTo",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), VALUE_STEP), lit2("func", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), VALUE_STEP), lit3("func", v3("z"))]
   ),
-  rule2(
+  rule3(
     "comesTo",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), VALUE_STEP), lit2("objectValue", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), VALUE_STEP), lit3("objectValue", v3("z"))]
   ),
   // An instance walk stops the same way, so a method read off
   // `new App()` still finds what the class declares.
-  rule2(
+  rule3(
     "comesTo",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), INSTANCE_STEP), lit2("func", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), INSTANCE_STEP), lit3("func", v3("z"))]
   ),
-  rule2(
+  rule3(
     "comesTo",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), INSTANCE_STEP), lit2("objectValue", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), INSTANCE_STEP), lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "givesBack",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), RESULT_STEP), lit2("func", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), RESULT_STEP), lit3("func", v3("z"))]
   ),
-  rule2(
+  rule3(
     "givesBack",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), RESULT_STEP), lit2("objectValue", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), RESULT_STEP), lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "givesBackUnwrapped",
-    [v2("x"), v2("z")],
+    [v3("x"), v3("z")],
     [
-      lit2("reaches", v2("x"), v2("r"), RESULT_STEP),
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesTo", v2("r"), v2("z")),
-      lit2("func", v2("z"))
+      lit3("reaches", v3("x"), v3("r"), RESULT_STEP),
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesTo", v3("r"), v3("z")),
+      lit3("func", v3("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.
-  rule2("isWrittenAs", [v2("x"), v2("x")], [lit2("writtenValue", v2("x"))]),
-  rule2("isWrittenAs", [v2("x"), v2("x")], [lit2("objectValue", v2("x"))]),
-  rule2(
+  rule3("isWrittenAs", [v3("x"), v3("x")], [lit3("writtenValue", v3("x"))]),
+  rule3("isWrittenAs", [v3("x"), v3("x")], [lit3("objectValue", v3("x"))]),
+  rule3(
     "isWrittenAs",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), VALUE_STEP), lit2("writtenValue", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), VALUE_STEP), lit3("writtenValue", v3("z"))]
   ),
-  rule2(
+  rule3(
     "isWrittenAs",
-    [v2("x"), v2("z")],
-    [lit2("reaches", v2("x"), v2("z"), VALUE_STEP), lit2("objectValue", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("reaches", v3("x"), v3("z"), VALUE_STEP), lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "isWrittenAs",
-    [v2("x"), v2("z")],
+    [v3("x"), v3("z")],
     [
-      lit2("invokes", v2("x"), v2("f")),
-      lit2("returnsValue", v2("f"), v2("ret")),
-      lit2("isWrittenAs", v2("ret"), v2("z"))
+      lit3("invokes", v3("x"), v3("f")),
+      lit3("returnsValue", v3("f"), v3("ret")),
+      lit3("isWrittenAs", v3("ret"), v3("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.
-  rule2(
+  rule3(
     "fallbackBehind",
-    [v2("x"), v2("x")],
-    [lit2("fallbackBranch", v2("x"), v2("b"))]
+    [v3("x"), v3("x")],
+    [lit3("fallbackBranch", v3("x"), v3("b"))]
   ),
-  rule2(
+  rule3(
     "fallbackBehind",
-    [v2("x"), v2("f")],
+    [v3("x"), v3("f")],
     [
-      lit2("reaches", v2("x"), v2("f"), VALUE_STEP),
-      lit2("fallbackBranch", v2("f"), v2("b"))
+      lit3("reaches", v3("x"), v3("f"), VALUE_STEP),
+      lit3("fallbackBranch", v3("f"), v3("b"))
     ]
   ),
-  rule2(
+  rule3(
     "fallbackBehind",
-    [v2("x"), v2("f")],
+    [v3("x"), v3("f")],
     [
-      lit2("invokes", v2("x"), v2("g")),
-      lit2("returnsValue", v2("g"), v2("ret")),
-      lit2("fallbackBehind", v2("ret"), v2("f"))
+      lit3("invokes", v3("x"), v3("g")),
+      lit3("returnsValue", v3("g"), v3("ret")),
+      lit3("fallbackBehind", v3("ret"), v3("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.
-  rule2(
+  rule3(
     "returnsCall",
-    [v2("f"), v2("c")],
-    [lit2("returnsValue", v2("f"), v2("v")), lit2("isWrittenAs", v2("v"), v2("c"))]
+    [v3("f"), v3("c")],
+    [lit3("returnsValue", v3("f"), v3("v")), lit3("isWrittenAs", v3("v"), v3("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.
-  rule2(
+  rule3(
     "passesArgument",
-    [v2("r"), v2("p"), v2("a")],
+    [v3("r"), v3("p"), v3("a")],
     [
-      lit2("callsFunction", v2("r"), v2("f")),
-      lit2("paramOf", v2("f"), v2("k"), v2("p")),
-      lit2("callArg", v2("r"), v2("k"), v2("a"))
+      lit3("callsFunction", v3("r"), v3("f")),
+      lit3("paramOf", v3("f"), v3("k"), v3("p")),
+      lit3("callArg", v3("r"), v3("k"), v3("a"))
     ]
   ),
-  rule2(
+  rule3(
     "passesArgument",
-    [v2("r"), v2("p"), v2("a")],
+    [v3("r"), v3("p"), v3("a")],
     [
-      lit2("callsFunction", v2("r"), v2("f")),
-      lit2("paramNamed", v2("f"), v2("n"), v2("p")),
-      lit2("callKeywordArg", v2("r"), v2("n"), v2("a"))
+      lit3("callsFunction", v3("r"), v3("f")),
+      lit3("paramNamed", v3("f"), v3("n"), v3("p")),
+      lit3("callKeywordArg", v3("r"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "refersToParam",
-    [v2("p"), v2("p")],
-    [lit2("paramOf", v2("f"), v2("k"), v2("p"))]
+    [v3("p"), v3("p")],
+    [lit3("paramOf", v3("f"), v3("k"), v3("p"))]
   ),
-  rule2(
+  rule3(
     "refersToParam",
-    [v2("p"), v2("p")],
-    [lit2("paramNamed", v2("f"), v2("n"), v2("p"))]
+    [v3("p"), v3("p")],
+    [lit3("paramNamed", v3("f"), v3("n"), v3("p"))]
   ),
   // No import step, since no module exports a parameter.
-  rule2(
+  rule3(
     "refersToParam",
-    [v2("x"), v2("p")],
-    [lit2("refersToParam", v2("y"), v2("p")), lit2("nameHop", v2("x"), v2("y"))]
+    [v3("x"), v3("p")],
+    [lit3("refersToParam", v3("y"), v3("p")), lit3("nameHop", v3("x"), v3("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.
-  rule2("runtimeObject", [v2("w")], [lit2("environmentObject", v2("w"))]),
-  rule2("runtimeObject", [v2("w")], [lit2("streamObject", v2("w"))]),
+  rule3("runtimeObject", [v3("w")], [lit3("environmentObject", v3("w"))]),
+  rule3("runtimeObject", [v3("w")], [lit3("streamObject", v3("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.
-  rule2(
+  rule3(
     "runtimeValue",
-    [v2("w"), v2("o")],
-    [lit2("runtimeObject", v2("w")), lit2("refersToObject", v2("o"), v2("w"))]
+    [v3("w"), v3("o")],
+    [lit3("runtimeObject", v3("w")), lit3("refersToObject", v3("o"), v3("w"))]
   ),
-  rule2(
+  rule3(
     "runtimeValue",
-    [v2("w"), v2("o")],
+    [v3("w"), v3("o")],
     [
-      lit2("runtimeValue", v2("w"), v2("a")),
-      lit2("passesArgument", v2("r"), v2("p"), v2("a")),
-      lit2("refersToParam", v2("o"), v2("p"))
+      lit3("runtimeValue", v3("w"), v3("a")),
+      lit3("passesArgument", v3("r"), v3("p"), v3("a")),
+      lit3("refersToParam", v3("o"), v3("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.
-  rule2(
+  rule3(
     "runtimeValue",
-    [v2("w"), v2("o")],
+    [v3("w"), v3("o")],
     [
-      lit2("runtimeValue", v2("w"), v2("d")),
-      lit2("paramDefault", v2("p"), v2("d")),
-      lit2("refersToParam", v2("o"), v2("p"))
+      lit3("runtimeValue", v3("w"), v3("d")),
+      lit3("paramDefault", v3("p"), v3("d")),
+      lit3("refersToParam", v3("o"), v3("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.
-  rule2(
+  rule3(
     "environmentRead",
-    [v2("w"), v2("site"), v2("x")],
+    [v3("w"), v3("site"), v3("x")],
     [
-      lit2("environmentObject", v2("w")),
-      lit2("runtimeValue", v2("w"), v2("o")),
-      lit2("readsKeyed", v2("site"), v2("o"), v2("x"))
+      lit3("environmentObject", v3("w")),
+      lit3("runtimeValue", v3("w"), v3("o")),
+      lit3("readsKeyed", v3("site"), v3("o"), v3("x"))
     ]
   ),
-  rule2(
+  rule3(
     "readsEnvNamed",
-    [v2("site"), v2("x")],
-    [lit2("environmentRead", v2("w"), v2("site"), v2("x"))]
+    [v3("site"), v3("x")],
+    [lit3("environmentRead", v3("w"), v3("site"), v3("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.
-  rule2(
+  rule3(
     "paramNamesEnv",
-    [v2("p"), v2("site")],
+    [v3("p"), v3("site")],
     [
-      lit2("readsEnvNamed", v2("site"), v2("x")),
-      lit2("refersToParam", v2("x"), v2("p"))
+      lit3("readsEnvNamed", v3("site"), v3("x")),
+      lit3("refersToParam", v3("x"), v3("p"))
     ]
   ),
-  rule2(
+  rule3(
     "paramNamesEnv",
-    [v2("p"), v2("site")],
+    [v3("p"), v3("site")],
     [
-      lit2("refersToParam", v2("a"), v2("p")),
-      lit2("passesArgument", v2("r"), v2("q"), v2("a")),
-      lit2("paramNamesEnv", v2("q"), v2("site"))
+      lit3("refersToParam", v3("a"), v3("p")),
+      lit3("passesArgument", v3("r"), v3("q"), v3("a")),
+      lit3("paramNamesEnv", v3("q"), v3("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.
-  rule2("typedAs", [v2("x"), v2("t")], [lit2("instanceOf", v2("x"), v2("t"))]),
-  rule2(
+  rule3("typedAs", [v3("x"), v3("t")], [lit3("instanceOf", v3("x"), v3("t"))]),
+  rule3(
     "typedAs",
-    [v2("x"), v2("t")],
+    [v3("x"), v3("t")],
     [
-      lit2("reaches", v2("x"), v2("y"), VALUE_STEP),
-      lit2("instanceOf", v2("y"), v2("t"))
+      lit3("reaches", v3("x"), v3("y"), VALUE_STEP),
+      lit3("instanceOf", v3("y"), v3("t"))
     ]
   ),
   // Which module's export a re-exported name forwards to, however
   // many barrels deep the forwarding runs.
-  rule2(
+  rule3(
     "moduleForwards",
-    [v2("m"), v2("n"), v2("m2"), v2("n2")],
-    [lit2("reExports", v2("m"), v2("n"), v2("m2"), v2("n2"))]
+    [v3("m"), v3("n"), v3("m2"), v3("n2")],
+    [lit3("reExports", v3("m"), v3("n"), v3("m2"), v3("n2"))]
   ),
-  rule2(
+  rule3(
     "moduleForwards",
-    [v2("m"), v2("n"), v2("m3"), v2("n3")],
+    [v3("m"), v3("n"), v3("m3"), v3("n3")],
     [
-      lit2("reExports", v2("m"), v2("n"), v2("m2"), v2("n2")),
-      lit2("moduleForwards", v2("m2"), v2("n2"), v2("m3"), v2("n3"))
+      lit3("reExports", v3("m"), v3("n"), v3("m2"), v3("n2")),
+      lit3("moduleForwards", v3("m2"), v3("n2"), v3("m3"), v3("n3"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
-  rule2(
+  rule3(
     "moduleExport",
-    [v2("m"), v2("n"), v2("value")],
-    [lit2("exportsAs", v2("m"), v2("n"), v2("value"))],
+    [v3("m"), v3("n"), v3("value")],
+    [lit3("exportsAs", v3("m"), v3("n"), v3("value"))],
     "export"
   ),
-  rule2(
+  rule3(
     "moduleExport",
-    [v2("m"), v2("n"), v2("value")],
+    [v3("m"), v3("n"), v3("value")],
     [
-      lit2("reExports", v2("m"), v2("n"), v2("m2"), v2("n2")),
-      lit2("moduleExport", v2("m2"), v2("n2"), v2("value"))
+      lit3("reExports", v3("m"), v3("n"), v3("m2"), v3("n2")),
+      lit3("moduleExport", v3("m2"), v3("n2"), v3("value"))
     ],
     "re-export"
   ),
-  rule2(
+  rule3(
     "moduleExport",
-    [v2("m"), v2("n"), v2("value")],
+    [v3("m"), v3("n"), v3("value")],
     [
-      lit2("reExportsAll", v2("m"), v2("m2")),
-      lit2("moduleExport", v2("m2"), v2("n"), v2("value"))
+      lit3("reExportsAll", v3("m"), v3("m2")),
+      lit3("moduleExport", v3("m2"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "invokes",
-    [v2("r"), v2("f")],
-    [lit2("call", v2("r"), v2("c")), lit2("comesTo", v2("c"), v2("f"))]
+    [v3("r"), v3("f")],
+    [lit3("call", v3("r"), v3("c")), lit3("comesTo", v3("c"), v3("f"))]
   ),
   // The callee is itself a call: `daoBuilder()()`.
-  rule2(
+  rule3(
     "invokes",
-    [v2("r"), v2("f")],
-    [lit2("call", v2("r"), v2("c")), lit2("givesBack", v2("c"), v2("f"))]
+    [v3("r"), v3("f")],
+    [lit3("call", v3("r"), v3("c")), lit3("givesBack", v3("c"), v3("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.
-  rule2(
+  rule3(
     "objectOf",
-    [v2("o"), v2("obj")],
-    [lit2("comesTo", v2("o"), v2("obj")), lit2("objectValue", v2("obj"))]
+    [v3("o"), v3("obj")],
+    [lit3("comesTo", v3("o"), v3("obj")), lit3("objectValue", v3("obj"))]
   ),
-  rule2(
+  rule3(
     "objectOf",
-    [v2("x"), v2("obj")],
-    [lit2("givesBack", v2("x"), v2("obj")), lit2("objectValue", v2("obj"))]
+    [v3("x"), v3("obj")],
+    [lit3("givesBack", v3("x"), v3("obj")), lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "objectOf",
-    [v2("site"), v2("site")],
-    [lit2("allocates", v2("site"), v2("c"))]
+    [v3("site"), v3("site")],
+    [lit3("allocates", v3("site"), v3("c"))]
   ),
-  rule2(
+  rule3(
     "objectOf",
-    [v2("o"), v2("site")],
+    [v3("o"), v3("site")],
     [
-      lit2("reaches", v2("o"), v2("site"), VALUE_STEP),
-      lit2("allocates", v2("site"), v2("c"))
+      lit3("reaches", v3("o"), v3("site"), VALUE_STEP),
+      lit3("allocates", v3("site"), v3("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.
-  rule2(
+  rule3(
     "objectOf",
-    [v2("o"), v2("site")],
+    [v3("o"), v3("site")],
     [
-      lit2("reaches", v2("o"), v2("site"), RESULT_STEP),
-      lit2("callArgCount", v2("site"), NO_ARGUMENTS),
-      lit2("allocates", v2("site"), v2("c"))
+      lit3("reaches", v3("o"), v3("site"), RESULT_STEP),
+      lit3("callArgCount", v3("site"), NO_ARGUMENTS),
+      lit3("allocates", v3("site"), v3("c"))
     ]
   ),
   // Which calls a function, found by the name the call is written as
@@ -3826,114 +3976,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.
-  rule2(
+  rule3(
     "callsNamed",
-    [v2("r"), v2("f")],
-    [lit2("binds", v2("c"), v2("f")), lit2("call", v2("r"), v2("c"))]
+    [v3("r"), v3("f")],
+    [lit3("binds", v3("c"), v3("f")), lit3("call", v3("r"), v3("c"))]
   ),
-  rule2(
+  rule3(
     "callsNamed",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("moduleExport", v2("m"), v2("n"), v2("f")),
-      lit2("imports", v2("c"), v2("m"), v2("n")),
-      lit2("call", v2("r"), v2("c"))
+      lit3("moduleExport", v3("m"), v3("n"), v3("f")),
+      lit3("imports", v3("c"), v3("m"), v3("n")),
+      lit3("call", v3("r"), v3("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.
-  rule2(
+  rule3(
     "callsNamed",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("moduleExport", v2("m"), v2("n"), v2("f")),
-      lit2("imports", v2("d"), v2("m"), v2("n")),
-      lit2("binds", v2("c"), v2("d")),
-      lit2("call", v2("r"), v2("c"))
+      lit3("moduleExport", v3("m"), v3("n"), v3("f")),
+      lit3("imports", v3("d"), v3("m"), v3("n")),
+      lit3("binds", v3("c"), v3("d")),
+      lit3("call", v3("r"), v3("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.
-  rule2(
+  rule3(
     "callsNamed",
-    [v2("r"), v2("f")],
-    [lit2("binds", v2("g"), v2("f")), lit2("callsNamed", v2("r"), v2("g"))]
+    [v3("r"), v3("f")],
+    [lit3("binds", v3("g"), v3("f")), lit3("callsNamed", v3("r"), v3("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.
-  rule2("callsFunction", [v2("r"), v2("f")], [lit2("callsNamed", v2("r"), v2("f"))]),
-  rule2(
+  rule3("callsFunction", [v3("r"), v3("f")], [lit3("callsNamed", v3("r"), v3("f"))]),
+  rule3(
     "callsFunction",
-    [v2("r"), v2("f")],
-    [lit2("binds", v2("g"), v2("f")), lit2("callsFunction", v2("r"), v2("g"))]
+    [v3("r"), v3("f")],
+    [lit3("binds", v3("g"), v3("f")), lit3("callsFunction", v3("r"), v3("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.
-  rule2(
+  rule3(
     "callsFunction",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("holdsProperty", v2("obj"), v2("n"), v2("f")),
-      lit2("refersToObject", v2("o"), v2("obj")),
-      lit2("readsProperty", v2("c"), v2("o"), v2("n")),
-      lit2("call", v2("r"), v2("c"))
+      lit3("holdsProperty", v3("obj"), v3("n"), v3("f")),
+      lit3("refersToObject", v3("o"), v3("obj")),
+      lit3("readsProperty", v3("c"), v3("o"), v3("n")),
+      lit3("call", v3("r"), v3("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.
-  rule2(
+  rule3(
     "callsFunction",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("returnsValue", v2("g"), v2("f")),
-      lit2("callsFunction", v2("r0"), v2("g")),
-      lit2("callsNamed", v2("r"), v2("r0"))
+      lit3("returnsValue", v3("g"), v3("f")),
+      lit3("callsFunction", v3("r0"), v3("g")),
+      lit3("callsNamed", v3("r"), v3("r0"))
     ]
   ),
   // The same, called straight off the factory's call, as
   // `register("created")(handler)` or a Python decorator written that way.
-  rule2(
+  rule3(
     "callsFunction",
-    [v2("r"), v2("f")],
+    [v3("r"), v3("f")],
     [
-      lit2("returnsValue", v2("g"), v2("f")),
-      lit2("callsFunction", v2("r0"), v2("g")),
-      lit2("call", v2("r"), v2("r0"))
+      lit3("returnsValue", v3("g"), v3("f")),
+      lit3("callsFunction", v3("r0"), v3("g")),
+      lit3("call", v3("r"), v3("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.
-  rule2("refersToObject", [v2("obj"), v2("obj")], [lit2("objectValue", v2("obj"))]),
+  rule3("refersToObject", [v3("obj"), v3("obj")], [lit3("objectValue", v3("obj"))]),
   // A construction is an object too, and the one a name for it refers to.
-  rule2(
+  rule3(
     "refersToObject",
-    [v2("site"), v2("site")],
-    [lit2("allocates", v2("site"), v2("c"))]
+    [v3("site"), v3("site")],
+    [lit3("allocates", v3("site"), v3("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.
-  rule2("refersToObject", [v2("w"), v2("w")], [lit2("runtimeObject", v2("w"))]),
+  rule3("refersToObject", [v3("w"), v3("w")], [lit3("runtimeObject", v3("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.
-  rule2(
+  rule3(
     "refersToObject",
-    [v2("x"), v2("obj")],
-    [lit2("nameHop", v2("x"), v2("y")), lit2("refersToObject", v2("y"), v2("obj"))]
+    [v3("x"), v3("obj")],
+    [lit3("nameHop", v3("x"), v3("y")), lit3("refersToObject", v3("y"), v3("obj"))]
   ),
-  rule2(
+  rule3(
     "refersToObject",
-    [v2("x"), v2("obj")],
+    [v3("x"), v3("obj")],
     [
-      lit2("imports", v2("x"), v2("m"), v2("n")),
-      lit2("moduleExport", v2("m"), v2("n"), v2("y")),
-      lit2("refersToObject", v2("y"), v2("obj"))
+      lit3("imports", v3("x"), v3("m"), v3("n")),
+      lit3("moduleExport", v3("m"), v3("n"), v3("y")),
+      lit3("refersToObject", v3("y"), v3("obj"))
     ]
   ),
   // What an object contains, its base class included, so a method the base
@@ -3941,417 +4091,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.
-  rule2(
+  rule3(
     "contains",
-    [v2("o"), v2("n"), v2("held")],
-    [lit2("holdsProperty", v2("o"), v2("n"), v2("held"))]
+    [v3("o"), v3("n"), v3("held")],
+    [lit3("holdsProperty", v3("o"), v3("n"), v3("held"))]
   ),
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("extends", v2("cls"), v2("base")),
-      lit2("comesTo", v2("base"), v2("baseCls")),
-      lit2("contains", v2("baseCls"), v2("n"), v2("held"))
+      lit3("extends", v3("cls"), v3("base")),
+      lit3("comesTo", v3("base"), v3("baseCls")),
+      lit3("contains", v3("baseCls"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("prepends", v2("cls"), v2("mod")),
-      lit2("comesTo", v2("mod"), v2("modObj")),
-      lit2("contains", v2("modObj"), v2("n"), v2("held"))
+      lit3("prepends", v3("cls"), v3("mod")),
+      lit3("comesTo", v3("mod"), v3("modObj")),
+      lit3("contains", v3("modObj"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("t")],
-    [lit2("declaresAssociation", v2("cls"), v2("n"), v2("t"))],
+    [v3("cls"), v3("n"), v3("t")],
+    [lit3("declaresAssociation", v3("cls"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("t")],
+    [v3("cls"), v3("n"), v3("t")],
     [
-      lit2("fieldCall", v2("cls"), v2("n"), v2("c"), v2("t")),
-      lit2("comesFrom", v2("c"), v2("m"), v2("name")),
-      lit2("associationConstructor", v2("m"), v2("name"))
+      lit3("fieldCall", v3("cls"), v3("n"), v3("c"), v3("t")),
+      lit3("comesFrom", v3("c"), v3("m"), v3("name")),
+      lit3("associationConstructor", v3("m"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("initializes", v2("cls"), v2("f")),
-      lit2("storesProperty", v2("f"), v2("n"), v2("held"), RECEIVER_STORE)
+      lit3("initializes", v3("cls"), v3("f")),
+      lit3("storesProperty", v3("f"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("holdsProperty", v2("cls"), v2("m"), v2("f")),
-      lit2("storesProperty", v2("f"), v2("n"), v2("held"), RECEIVER_STORE)
+      lit3("holdsProperty", v3("cls"), v3("m"), v3("f")),
+      lit3("storesProperty", v3("f"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("obj"), v2("n"), v2("held")],
+    [v3("obj"), v3("n"), v3("held")],
     [
-      lit2("storesProperty", v2("x"), v2("n"), v2("held"), NAMED_STORE),
-      lit2("refersToObject", v2("x"), v2("obj"))
+      lit3("storesProperty", v3("x"), v3("n"), v3("held"), NAMED_STORE),
+      lit3("refersToObject", v3("x"), v3("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.
-  rule2(
+  rule3(
     "overrides",
-    [v2("m"), v2("n"), v2("h")],
+    [v3("m"), v3("n"), v3("h")],
     [
-      lit2("holdsProperty", v2("c"), v2("n"), v2("m")),
-      lit2("extends", v2("c"), v2("b")),
-      lit2("comesTo", v2("b"), v2("base")),
-      lit2("contains", v2("base"), v2("n"), v2("h"))
+      lit3("holdsProperty", v3("c"), v3("n"), v3("m")),
+      lit3("extends", v3("c"), v3("b")),
+      lit3("comesTo", v3("b"), v3("base")),
+      lit3("contains", v3("base"), v3("n"), v3("h"))
     ]
   ),
   // The same for a field default, which a plain subclass contains too.
-  rule2(
+  rule3(
     "overrides",
-    [v2("m"), v2("n"), v2("h")],
+    [v3("m"), v3("n"), v3("h")],
     [
-      lit2("declaresDefault", v2("c"), v2("n"), v2("m")),
-      lit2("extends", v2("c"), v2("b")),
-      lit2("comesTo", v2("b"), v2("base")),
-      lit2("contains", v2("base"), v2("n"), v2("h"))
+      lit3("declaresDefault", v3("c"), v3("n"), v3("m")),
+      lit3("extends", v3("c"), v3("b")),
+      lit3("comesTo", v3("b"), v3("base")),
+      lit3("contains", v3("base"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "overrides",
-    [v2("m"), v2("n"), v2("h")],
+    [v3("m"), v3("n"), v3("h")],
     [
-      lit2("holdsProperty", v2("modObj"), v2("n"), v2("m")),
-      lit2("nameHop", v2("mod"), v2("modObj")),
-      lit2("prepends", v2("c"), v2("mod")),
-      lit2("holdsProperty", v2("c"), v2("n"), v2("h"))
+      lit3("holdsProperty", v3("modObj"), v3("n"), v3("m")),
+      lit3("nameHop", v3("mod"), v3("modObj")),
+      lit3("prepends", v3("c"), v3("mod")),
+      lit3("holdsProperty", v3("c"), v3("n"), v3("h"))
     ]
   ),
-  rule2(
+  rule3(
     "overrides",
-    [v2("m"), v2("n"), v2("h")],
-    [
-      lit2("holdsProperty", v2("modObj"), v2("n"), v2("m")),
-      lit2("nameHop", v2("mod"), v2("modObj")),
-      lit2("prepends", v2("c"), v2("mod")),
-      lit2("extends", v2("c"), v2("b")),
-      lit2("comesTo", v2("b"), v2("base")),
-      lit2("contains", v2("base"), v2("n"), v2("h"))
+    [v3("m"), v3("n"), v3("h")],
+    [
+      lit3("holdsProperty", v3("modObj"), v3("n"), v3("m")),
+      lit3("nameHop", v3("mod"), v3("modObj")),
+      lit3("prepends", v3("c"), v3("mod")),
+      lit3("extends", v3("c"), v3("b")),
+      lit3("comesTo", v3("b"), v3("base")),
+      lit3("contains", v3("base"), v3("n"), v3("h"))
     ]
   ),
   // The objects a read reads a name off, and on each one the members the
   // read finds that another member there overrides.
-  rule2(
+  rule3(
     "readsFrom",
-    [v2("x"), v2("obj"), v2("n")],
+    [v3("x"), v3("obj"), v3("n")],
     [
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("objectOf", v2("o"), v2("obj"))
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("objectOf", v3("o"), v3("obj"))
     ]
   ),
-  rule2(
+  rule3(
     "readsOverridden",
-    [v2("x"), v2("obj"), v2("h")],
+    [v3("x"), v3("obj"), v3("h")],
     [
-      lit2("readsFrom", v2("x"), v2("obj"), v2("n")),
-      lit2("contains", v2("obj"), v2("n"), v2("m")),
-      lit2("overrides", v2("m"), v2("n"), v2("h"))
+      lit3("readsFrom", v3("x"), v3("obj"), v3("n")),
+      lit3("contains", v3("obj"), v3("n"), v3("m")),
+      lit3("overrides", v3("m"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "readsMemberOn",
-    [v2("x"), v2("obj"), v2("h")],
+    [v3("x"), v3("obj"), v3("h")],
     [
-      lit2("readsOverridden", v2("x"), v2("shadowing"), v2("overridden")),
-      lit2("readsFrom", v2("x"), v2("obj"), v2("n")),
-      lit2("contains", v2("obj"), v2("n"), v2("h"))
+      lit3("readsOverridden", v3("x"), v3("shadowing"), v3("overridden")),
+      lit3("readsFrom", v3("x"), v3("obj"), v3("n")),
+      lit3("contains", v3("obj"), v3("n"), v3("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`.
-  rule2(
+  rule3(
     "constructsNamed",
-    [v2("r"), v2("cls")],
-    [lit2("objectValue", v2("cls")), lit2("callsNamed", v2("r"), v2("cls"))]
+    [v3("r"), v3("cls")],
+    [lit3("objectValue", v3("cls")), lit3("callsNamed", v3("r"), v3("cls"))]
   ),
   // Each construction is an object of its own containing what its
   // class stores, so two sites are two objects.
-  rule2(
+  rule3(
     "contains",
-    [v2("site"), v2("n"), v2("held")],
+    [v3("site"), v3("n"), v3("held")],
     [
-      lit2("allocates", v2("site"), v2("cls")),
-      lit2("contains", v2("cls"), v2("n"), v2("held"))
+      lit3("allocates", v3("site"), v3("cls")),
+      lit3("contains", v3("cls"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "contains",
-    [v2("site"), v2("n"), v2("held")],
+    [v3("site"), v3("n"), v3("held")],
     [
-      lit2("callArgCount", v2("site"), NO_ARGUMENTS),
-      lit2("call", v2("site"), v2("c")),
-      lit2("comesTo", v2("c"), v2("cls")),
-      lit2("objectValue", v2("cls")),
-      lit2("fieldDefault", v2("cls"), v2("n"), v2("held"))
+      lit3("callArgCount", v3("site"), NO_ARGUMENTS),
+      lit3("call", v3("site"), v3("c")),
+      lit3("comesTo", v3("c"), v3("cls")),
+      lit3("objectValue", v3("cls")),
+      lit3("fieldDefault", v3("cls"), v3("n"), v3("held"))
     ],
     "construction with no arguments"
   ),
   // On a plain class nothing generates a constructor that could replace
   // an annotated attribute, so every instance shares it.
-  rule2(
+  rule3(
     "contains",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("declaresDefault", v2("cls"), v2("n"), v2("held")),
-      lit2("plainAncestry", v2("cls"))
+      lit3("declaresDefault", v3("cls"), v3("n"), v3("held")),
+      lit3("plainAncestry", v3("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.
-  rule2("plainAncestry", [v2("c")], [lit2("plainClass", v2("c"))]),
-  rule2(
+  rule3("plainAncestry", [v3("c")], [lit3("plainClass", v3("c"))]),
+  rule3(
     "plainAncestry",
-    [v2("c")],
+    [v3("c")],
     [
-      lit2("extendsOnly", v2("c"), v2("base")),
-      lit2("comesTo", v2("base"), v2("baseCls")),
-      lit2("plainAncestry", v2("baseCls"))
+      lit3("extendsOnly", v3("c"), v3("base")),
+      lit3("comesTo", v3("base"), v3("baseCls")),
+      lit3("plainAncestry", v3("baseCls"))
     ]
   ),
   // A field default, its base class's included. It stays out of `contains`,
   // which every instance reads, because a constructor may replace it.
-  rule2(
+  rule3(
     "fieldDefault",
-    [v2("cls"), v2("n"), v2("held")],
-    [lit2("declaresDefault", v2("cls"), v2("n"), v2("held"))]
+    [v3("cls"), v3("n"), v3("held")],
+    [lit3("declaresDefault", v3("cls"), v3("n"), v3("held"))]
   ),
-  rule2(
+  rule3(
     "fieldDefault",
-    [v2("cls"), v2("n"), v2("held")],
+    [v3("cls"), v3("n"), v3("held")],
     [
-      lit2("extends", v2("cls"), v2("base")),
-      lit2("comesTo", v2("base"), v2("baseCls")),
-      lit2("fieldDefault", v2("baseCls"), v2("n"), v2("held"))
+      lit3("extends", v3("cls"), v3("base")),
+      lit3("comesTo", v3("base"), v3("baseCls")),
+      lit3("fieldDefault", v3("baseCls"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "allocates",
-    [v2("site"), v2("cls")],
+    [v3("site"), v3("cls")],
     [
-      lit2("call", v2("site"), v2("c")),
-      lit2("stepsTo", v2("site"), v2("cls"), INSTANCE_STEP)
+      lit3("call", v3("site"), v3("c")),
+      lit3("stepsTo", v3("site"), v3("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.
-  rule2("libraryBase", [v2("c"), v2("n")], [lit2("extendsNamed", v2("c"), v2("n"))]),
-  rule2(
+  rule3("libraryBase", [v3("c"), v3("n")], [lit3("extendsNamed", v3("c"), v3("n"))]),
+  rule3(
     "libraryBase",
-    [v2("c"), v2("n")],
+    [v3("c"), v3("n")],
     [
-      lit2("extends", v2("c"), v2("x")),
-      lit2("comesTo", v2("x"), v2("b")),
-      lit2("libraryBase", v2("b"), v2("n"))
+      lit3("extends", v3("c"), v3("x")),
+      lit3("comesTo", v3("x"), v3("b")),
+      lit3("libraryBase", v3("b"), v3("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.
-  rule2(
+  rule3(
     "libraryBase",
-    [v2("c"), v2("n")],
+    [v3("c"), v3("n")],
     [
-      lit2("extends", v2("c"), v2("x")),
-      lit2("isWrittenAs", v2("x"), v2("r")),
-      lit2("call", v2("r"), v2("cc")),
-      lit2("comesFrom", v2("cc"), v2("m"), v2("n"))
+      lit3("extends", v3("c"), v3("x")),
+      lit3("isWrittenAs", v3("x"), v3("r")),
+      lit3("call", v3("r"), v3("cc")),
+      lit3("comesFrom", v3("cc"), v3("m"), v3("n"))
     ]
   ),
   // Which function a factory returns, and which of its parameters that
   // function calls: together they are what makes it a wrapper.
-  rule2(
+  rule3(
     "returnsFunc",
-    [v2("f"), v2("g")],
+    [v3("f"), v3("g")],
     [
-      lit2("returnsValue", v2("f"), v2("value")),
-      lit2("comesTo", v2("value"), v2("g")),
-      lit2("func", v2("g"))
+      lit3("returnsValue", v3("f"), v3("value")),
+      lit3("comesTo", v3("value"), v3("g")),
+      lit3("func", v3("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.
-  rule2("bodyCallsDeep", [v2("f"), v2("c")], [lit2("bodyCalls", v2("f"), v2("c"))]),
-  rule2(
+  rule3("bodyCallsDeep", [v3("f"), v3("c")], [lit3("bodyCalls", v3("f"), v3("c"))]),
+  rule3(
     "bodyCallsDeep",
-    [v2("f"), v2("c")],
-    [lit2("containsFn", v2("f"), v2("g")), lit2("bodyCallsDeep", v2("g"), v2("c"))]
+    [v3("f"), v3("c")],
+    [lit3("containsFn", v3("f"), v3("g")), lit3("bodyCallsDeep", v3("g"), v3("c"))]
   ),
-  rule2(
+  rule3(
     "unwraps",
-    [v2("f"), v2("k")],
+    [v3("f"), v3("k")],
     [
-      lit2("returnsFunc", v2("f"), v2("g")),
-      lit2("bodyCallsDeep", v2("g"), v2("c")),
-      lit2("refersToParam", v2("c"), v2("p")),
-      lit2("paramOf", v2("f"), v2("k"), v2("p"))
+      lit3("returnsFunc", v3("f"), v3("g")),
+      lit3("bodyCallsDeep", v3("g"), v3("c")),
+      lit3("refersToParam", v3("c"), v3("p")),
+      lit3("paramOf", v3("f"), v3("k"), v3("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.
-  rule2(
+  rule3(
     "flowsToParam",
-    [v2("x"), v2("p")],
-    [lit2("refersToParam", v2("x"), v2("p"))]
+    [v3("x"), v3("p")],
+    [lit3("refersToParam", v3("x"), v3("p"))]
   ),
-  rule2(
+  rule3(
     "flowsToParam",
-    [v2("r"), v2("p")],
+    [v3("r"), v3("p")],
     [
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesTo", v2("c"), v2("f")),
-      lit2("unwraps", v2("f"), v2("k")),
-      lit2("callArg", v2("r"), v2("k"), v2("a")),
-      lit2("flowsToParam", v2("a"), v2("p"))
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesTo", v3("c"), v3("f")),
+      lit3("unwraps", v3("f"), v3("k")),
+      lit3("callArg", v3("r"), v3("k"), v3("a")),
+      lit3("flowsToParam", v3("a"), v3("p"))
     ]
   ),
-  rule2(
+  rule3(
     "unwraps",
-    [v2("f"), v2("k")],
+    [v3("f"), v3("k")],
     [
-      lit2("returnsValue", v2("f"), v2("value")),
-      lit2("flowsToParam", v2("value"), v2("p")),
-      lit2("paramOf", v2("f"), v2("k"), v2("p"))
+      lit3("returnsValue", v3("f"), v3("value")),
+      lit3("flowsToParam", v3("value"), v3("p")),
+      lit3("paramOf", v3("f"), v3("k"), v3("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.
-  rule2(
+  rule3(
     "comesFrom",
-    [v2("x"), v2("m"), v2("n")],
-    [lit2("imports", v2("x"), v2("m"), v2("n"))]
+    [v3("x"), v3("m"), v3("n")],
+    [lit3("imports", v3("x"), v3("m"), v3("n"))]
   ),
-  rule2(
+  rule3(
     "comesFrom",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("reaches", v2("x"), v2("y"), VALUE_STEP),
-      lit2("imports", v2("y"), v2("m"), v2("n"))
+      lit3("reaches", v3("x"), v3("y"), VALUE_STEP),
+      lit3("imports", v3("y"), v3("m"), v3("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.
-  rule2(
+  rule3(
     "comesFrom",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("readsProperty", v2("x"), v2("ns"), v2("n")),
-      lit2("imports", v2("ns"), v2("m"), NAMESPACE_IMPORT)
+      lit3("readsProperty", v3("x"), v3("ns"), v3("n")),
+      lit3("imports", v3("ns"), v3("m"), NAMESPACE_IMPORT)
     ],
     NAMESPACE_MEMBER_RULE
   ),
-  rule2(
+  rule3(
     "comesFrom",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("reaches", v2("o"), v2("ns"), VALUE_STEP),
-      lit2("imports", v2("ns"), v2("m"), NAMESPACE_IMPORT)
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("reaches", v3("o"), v3("ns"), VALUE_STEP),
+      lit3("imports", v3("ns"), v3("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`.
-  rule2(
+  rule3(
     "comesFrom",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("readsProperty", v2("x"), v2("o"), v2("n")),
-      lit2("reaches", v2("o"), v2("d"), VALUE_STEP),
-      lit2("imports", v2("d"), v2("m"), DEFAULT_IMPORT)
+      lit3("readsProperty", v3("x"), v3("o"), v3("n")),
+      lit3("reaches", v3("o"), v3("d"), VALUE_STEP),
+      lit3("imports", v3("d"), v3("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.
-  rule2(
+  rule3(
     "callsInto",
-    [v2("f"), v2("m"), v2("n")],
+    [v3("f"), v3("m"), v3("n")],
     [
-      lit2("bodyCallsDeep", v2("f"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("m"), v2("n"))
+      lit3("bodyCallsDeep", v3("f"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("m"), v3("n"))
     ]
   ),
-  rule2(
+  rule3(
     "callsInto",
-    [v2("f"), v2("m"), v2("n")],
+    [v3("f"), v3("m"), v3("n")],
     [
-      lit2("bodyCallsDeep", v2("f"), v2("c")),
-      lit2("comesTo", v2("c"), v2("g")),
-      lit2("callsInto", v2("g"), v2("m"), v2("n"))
+      lit3("bodyCallsDeep", v3("f"), v3("c")),
+      lit3("comesTo", v3("c"), v3("g")),
+      lit3("callsInto", v3("g"), v3("m"), v3("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.
-  rule2(
+  rule3(
     "resolves",
-    [v2("x"), v2("z")],
-    [lit2("comesTo", v2("x"), v2("z")), lit2("func", v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("comesTo", v3("x"), v3("z")), lit3("func", v3("z"))]
   ),
   ...DISPATCH_RULES,
-  ...PASSED_ON_RULES
+  ...PASSED_ON_RULES,
+  ...SELF_RULES
 ];
 function alsoSteps(rules) {
   return [
@@ -4362,52 +4513,52 @@ function alsoSteps(rules) {
 var RESOLUTION_RULES = alsoSteps(STATED_RULES);
 var SOURCE_STEPS = [VALUE_STEP, RESULT_STEP];
 var WRITTEN_KEY_READS = [
-  lit2("readsProperty", v2("y"), v2("o"), v2("n")),
-  lit2("readsEntry", v2("y"), v2("o"), v2("n"))
+  lit3("readsProperty", v3("y"), v3("o"), v3("n")),
+  lit3("readsEntry", v3("y"), v3("o"), v3("n"))
 ];
 var SOURCE_READS = [
   ...WRITTEN_KEY_READS,
-  lit2("readsKeyed", v2("y"), v2("o"), v2("k"))
+  lit3("readsKeyed", v3("y"), v3("o"), v3("k"))
 ];
 function writtenAnswers(asking) {
   return [
-    rule2(
+    rule3(
       "wantedIsWrittenAs",
-      [v2("x"), v2("z")],
-      [lit2(asking, v2("x")), lit2("isWrittenAs", v2("x"), v2("z"))]
+      [v3("x"), v3("z")],
+      [lit3(asking, v3("x")), lit3("isWrittenAs", v3("x"), v3("z"))]
     ),
-    rule2(
+    rule3(
       "wantedFallbackBehind",
-      [v2("x"), v2("f")],
-      [lit2(asking, v2("x")), lit2("fallbackBehind", v2("x"), v2("f"))]
+      [v3("x"), v3("f")],
+      [lit3(asking, v3("x")), lit3("fallbackBehind", v3("x"), v3("f"))]
     ),
-    rule2(
+    rule3(
       "wantedReadsOverridden",
-      [v2("x"), v2("obj"), v2("h")],
-      [lit2(asking, v2("x")), lit2("readsOverridden", v2("x"), v2("obj"), v2("h"))]
+      [v3("x"), v3("obj"), v3("h")],
+      [lit3(asking, v3("x")), lit3("readsOverridden", v3("x"), v3("obj"), v3("h"))]
     ),
-    rule2(
+    rule3(
       "wantedReadsMemberOn",
-      [v2("x"), v2("obj"), v2("h")],
-      [lit2(asking, v2("x")), lit2("readsMemberOn", v2("x"), v2("obj"), v2("h"))]
+      [v3("x"), v3("obj"), v3("h")],
+      [lit3(asking, v3("x")), lit3("readsMemberOn", v3("x"), v3("obj"), v3("h"))]
     )
   ];
 }
 var RESOLUTION_QUESTIONS = [
-  rule2(
+  rule3(
     "wantedResolves",
-    [v2("x"), v2("z")],
-    [lit2("wanted", v2("x")), lit2("resolves", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("wanted", v3("x")), lit3("resolves", v3("x"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "wantedComesTo",
-    [v2("x"), v2("z")],
-    [lit2("wanted", v2("x")), lit2("comesTo", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("wanted", v3("x")), lit3("comesTo", v3("x"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "wantedComesTo",
-    [v2("x"), v2("z")],
-    [lit2("wantedOrigin", v2("x")), lit2("comesTo", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("wantedOrigin", v3("x")), lit3("comesTo", v3("x"), v3("z"))]
   ),
   ...writtenAnswers("wanted"),
   // A caller that reads only what a value is written as asks this way,
@@ -4416,666 +4567,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.
-  rule2(
+  rule3(
     "wantedObjectOf",
-    [v2("x"), v2("z")],
+    [v3("x"), v3("z")],
     [
-      lit2("wanted", v2("x")),
-      lit2("objectOf", v2("x"), v2("z")),
-      lit2("objectValue", v2("z"))
+      lit3("wanted", v3("x")),
+      lit3("objectOf", v3("x"), v3("z")),
+      lit3("objectValue", v3("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.
-  rule2(
+  rule3(
     "wantedIsWrittenAsUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("wantedUnder", v2("x"), v2("c")),
-      lit2("isWrittenAsUnder", v2("x"), v2("c"), v2("z"))
+      lit3("wantedUnder", v3("x"), v3("c")),
+      lit3("isWrittenAsUnder", v3("x"), v3("c"), v3("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.
-  rule2(
+  rule3(
     "wantedAllocatedAt",
-    [v2("cls"), v2("site")],
+    [v3("cls"), v3("site")],
     [
-      lit2("wantedSites", v2("cls")),
-      lit2("constructsNamed", v2("site"), v2("cls")),
-      lit2("allocates", v2("site"), v2("cls"))
+      lit3("wantedSites", v3("cls")),
+      lit3("constructsNamed", v3("site"), v3("cls")),
+      lit3("allocates", v3("site"), v3("cls"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedComesToUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("wantedUnder", v2("x"), v2("c")),
-      lit2("comesToUnder", v2("x"), v2("c"), v2("z"))
+      lit3("wantedUnder", v3("x"), v3("c")),
+      lit3("comesToUnder", v3("x"), v3("c"), v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedObjectOfUnder",
-    [v2("x"), v2("c"), v2("z")],
+    [v3("x"), v3("c"), v3("z")],
     [
-      lit2("wantedUnder", v2("x"), v2("c")),
-      lit2("objectOfUnder", v2("x"), v2("c"), v2("z"))
+      lit3("wantedUnder", v3("x"), v3("c")),
+      lit3("objectOfUnder", v3("x"), v3("c"), v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedFallbackBehindUnder",
-    [v2("x"), v2("c"), v2("f")],
+    [v3("x"), v3("c"), v3("f")],
     [
-      lit2("wantedUnder", v2("x"), v2("c")),
-      lit2("fallbackBehindUnder", v2("x"), v2("c"), v2("f"))
+      lit3("wantedUnder", v3("x"), v3("c")),
+      lit3("fallbackBehindUnder", v3("x"), v3("c"), v3("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.
-  rule2(
+  rule3(
     "wantedGivesBack",
-    [v2("x"), v2("z")],
-    [lit2("wanted", v2("x")), lit2("givesBack", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("wanted", v3("x")), lit3("givesBack", v3("x"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "wantedGivesBackUnwrapped",
-    [v2("x"), v2("z")],
-    [lit2("wanted", v2("x")), lit2("givesBackUnwrapped", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("wanted", v3("x")), lit3("givesBackUnwrapped", v3("x"), v3("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.
-  rule2(
+  rule3(
     "wantedPassesArgument",
-    [v2("p"), v2("r"), v2("a")],
-    [lit2("wanted", v2("p")), lit2("passesArgument", v2("r"), v2("p"), v2("a"))]
+    [v3("p"), v3("r"), v3("a")],
+    [lit3("wanted", v3("p")), lit3("passesArgument", v3("r"), v3("p"), v3("a"))]
   ),
-  rule2(
+  rule3(
     "wantedReturnsCall",
-    [v2("f"), v2("c")],
-    [lit2("wanted", v2("f")), lit2("returnsCall", v2("f"), v2("c"))]
+    [v3("f"), v3("c")],
+    [lit3("wanted", v3("f")), lit3("returnsCall", v3("f"), v3("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.
-  rule2(
+  rule3(
     "wantedParamNamesEnv",
-    [v2("p"), v2("site")],
+    [v3("p"), v3("site")],
     [
-      lit2("wantedEnvObject", v2("w")),
-      lit2("environmentRead", v2("w"), v2("site"), v2("x")),
-      lit2("paramNamesEnv", v2("p"), v2("site"))
+      lit3("wantedEnvObject", v3("w")),
+      lit3("environmentRead", v3("w"), v3("site"), v3("x")),
+      lit3("paramNamesEnv", v3("p"), v3("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.
-  rule2(
+  rule3(
     "wantedEnvParameter",
-    [v2("p")],
+    [v3("p")],
     [
-      lit2("wantedEnvObject", v2("w")),
-      lit2("runtimeValue", v2("w"), v2("p")),
-      lit2("paramNamed", v2("f"), v2("n"), v2("p"))
+      lit3("wantedEnvObject", v3("w")),
+      lit3("runtimeValue", v3("w"), v3("p")),
+      lit3("paramNamed", v3("f"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "wantedEnvPassingCall",
-    [v2("r")],
+    [v3("r")],
     [
-      lit2("wantedEnvObject", v2("w")),
-      lit2("runtimeValue", v2("w"), v2("a")),
-      lit2("callArg", v2("r"), v2("k"), v2("a"))
+      lit3("wantedEnvObject", v3("w")),
+      lit3("runtimeValue", v3("w"), v3("a")),
+      lit3("callArg", v3("r"), v3("k"), v3("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.
-  rule2(
+  rule3(
     "wantedEnvironmentValue",
-    [v2("o"), v2("w")],
+    [v3("o"), v3("w")],
     [
-      lit2("wanted", v2("o")),
-      lit2("runtimeValue", v2("w"), v2("o")),
-      lit2("environmentObject", v2("w"))
+      lit3("wanted", v3("o")),
+      lit3("runtimeValue", v3("w"), v3("o")),
+      lit3("environmentObject", v3("w"))
     ]
   ),
   // Every expression an output stream reaches, from the spots that spell
   // one, so a writer at `out.write(...)` looks its receiver up.
-  rule2(
+  rule3(
     "wantedStreamValue",
-    [v2("o"), v2("w")],
-    [lit2("wantedStreamObject", v2("w")), lit2("runtimeValue", v2("w"), v2("o"))]
+    [v3("o"), v3("w")],
+    [lit3("wantedStreamObject", v3("w")), lit3("runtimeValue", v3("w"), v3("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.
-  rule2("exitStart", [v2("x"), v2("x")], [lit2("wantedExitSink", v2("x"))]),
+  rule3("exitStart", [v3("x"), v3("x")], [lit3("wantedExitSink", v3("x"))]),
   // `reaches` takes no step through a call that picks its function from a
   // table, so the walk starts again from what each function there returns.
-  rule2(
+  rule3(
     "exitStart",
-    [v2("x"), v2("ret")],
+    [v3("x"), v3("ret")],
     [
-      lit2("exitReached", v2("x"), v2("y")),
-      lit2("dispatchesTo", v2("y"), v2("f")),
-      lit2("returnsValue", v2("f"), v2("ret"))
+      lit3("exitReached", v3("x"), v3("y")),
+      lit3("dispatchesTo", v3("y"), v3("f")),
+      lit3("returnsValue", v3("f"), v3("ret"))
     ]
   ),
-  rule2("exitReached", [v2("x"), v2("s")], [lit2("exitStart", v2("x"), v2("s"))]),
-  rule2(
+  rule3("exitReached", [v3("x"), v3("s")], [lit3("exitStart", v3("x"), v3("s"))]),
+  rule3(
     "exitReached",
-    [v2("x"), v2("y")],
+    [v3("x"), v3("y")],
     [
-      lit2("exitStart", v2("x"), v2("s")),
-      lit2("reaches", v2("s"), v2("y"), v2("kind"))
+      lit3("exitStart", v3("x"), v3("s")),
+      lit3("reaches", v3("s"), v3("y"), v3("kind"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedExitCodeFrom",
-    [v2("x"), v2("f")],
-    [lit2("exitReached", v2("x"), v2("y")), lit2("invokes", v2("y"), v2("f"))]
+    [v3("x"), v3("f")],
+    [lit3("exitReached", v3("x"), v3("y")), lit3("invokes", v3("y"), v3("f"))]
   ),
-  rule2(
+  rule3(
     "wantedExitCodeFrom",
-    [v2("x"), v2("f")],
-    [lit2("exitReached", v2("x"), v2("y")), lit2("dispatchesTo", v2("y"), v2("f"))]
+    [v3("x"), v3("f")],
+    [lit3("exitReached", v3("x"), v3("y")), lit3("dispatchesTo", v3("y"), v3("f"))]
   ),
   // The functions a call may run when it takes one from a table, with the
   // entry each came from, and the entries that come to no function. The
   // reader in dispatch.ts decides whether the call runs exactly one.
-  rule2(
+  rule3(
     "wantedDispatchSite",
-    [v2("r"), v2("site")],
-    [lit2("wantedDispatch", v2("r")), lit2("callsEntryAt", v2("r"), v2("site"))]
+    [v3("r"), v3("site")],
+    [lit3("wantedDispatch", v3("r")), lit3("callsEntryAt", v3("r"), v3("site"))]
   ),
-  rule2(
+  rule3(
     "wantedDispatchEntry",
-    [v2("r"), v2("held")],
+    [v3("r"), v3("held")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("entryAt", v2("site"), v2("held"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("entryAt", v3("site"), v3("held"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedDispatchInBranch",
-    [v2("r"), v2("site")],
+    [v3("r"), v3("site")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryInBranch", v2("r"), v2("site"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryInBranch", v3("r"), v3("site"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedDispatchComputed",
-    [v2("r"), v2("held")],
+    [v3("r"), v3("held")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("computedEntryAt", v2("site"), v2("held"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("computedEntryAt", v3("site"), v3("held"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedDispatchFunction",
-    [v2("r"), v2("held"), v2("f")],
+    [v3("r"), v3("held"), v3("f")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("entryAt", v2("site"), v2("held")),
-      lit2("comesTo", v2("held"), v2("f")),
-      lit2("func", v2("f"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("entryAt", v3("site"), v3("held")),
+      lit3("comesTo", v3("held"), v3("f")),
+      lit3("func", v3("f"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedDispatchLikeEntry",
-    [v2("r"), v2("site"), v2("n"), v2("held")],
+    [v3("r"), v3("site"), v3("n"), v3("held")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("likeEntryAt", v2("site"), v2("n"), v2("held"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("likeEntryAt", v3("site"), v3("n"), v3("held"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedDispatchLikeFunction",
-    [v2("r"), v2("held"), v2("f")],
+    [v3("r"), v3("held"), v3("f")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("callsEntryAt", v2("r"), v2("site")),
-      lit2("likeEntryAt", v2("site"), v2("n"), v2("held")),
-      lit2("comesTo", v2("held"), v2("f")),
-      lit2("func", v2("f"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("callsEntryAt", v3("r"), v3("site")),
+      lit3("likeEntryAt", v3("site"), v3("n"), v3("held")),
+      lit3("comesTo", v3("held"), v3("f")),
+      lit3("func", v3("f"))
     ]
   ),
   // What a function there calls in its own body, for an entry written as
   // a lambda, which no summary describes.
-  rule2(
+  rule3(
     "wantedDispatchThrough",
-    [v2("r"), v2("f"), v2("g")],
+    [v3("r"), v3("f"), v3("g")],
     [
-      lit2("wantedDispatch", v2("r")),
-      lit2("dispatchesTo", v2("r"), v2("f")),
-      lit2("makesCall", v2("f"), v2("r2")),
-      lit2("invokes", v2("r2"), v2("g"))
+      lit3("wantedDispatch", v3("r")),
+      lit3("dispatchesTo", v3("r"), v3("f")),
+      lit3("makesCall", v3("f"), v3("r2")),
+      lit3("invokes", v3("r2"), v3("g"))
     ]
   ),
   // The calls that hand a stream on, so the asker can read the callee's file.
-  rule2(
+  rule3(
     "wantedStreamPassingCall",
-    [v2("r")],
+    [v3("r")],
     [
-      lit2("wantedStreamObject", v2("w")),
-      lit2("runtimeValue", v2("w"), v2("a")),
-      lit2("callArg", v2("r"), v2("k"), v2("a"))
+      lit3("wantedStreamObject", v3("w")),
+      lit3("runtimeValue", v3("w"), v3("a")),
+      lit3("callArg", v3("r"), v3("k"), v3("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.
-  rule2(
+  rule3(
     "wantedRefersToParam",
-    [v2("o"), v2("p")],
-    [lit2("wanted", v2("o")), lit2("refersToParam", v2("o"), v2("p"))]
+    [v3("o"), v3("p")],
+    [lit3("wanted", v3("o")), lit3("refersToParam", v3("o"), v3("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.
-  rule2(
+  rule3(
     "wantedTypedAs",
-    [v2("x"), v2("t")],
-    [lit2("wantedType", v2("x")), lit2("typedAs", v2("x"), v2("t"))]
+    [v3("x"), v3("t")],
+    [lit3("wantedType", v3("x")), lit3("typedAs", v3("x"), v3("t"))]
   ),
-  rule2(
+  rule3(
     "wantedTypePassed",
-    [v2("o"), v2("a")],
+    [v3("o"), v3("a")],
     [
-      lit2("wantedType", v2("o")),
-      lit2("refersToParam", v2("o"), v2("p")),
-      lit2("passesArgument", v2("r"), v2("p"), v2("a"))
+      lit3("wantedType", v3("o")),
+      lit3("refersToParam", v3("o"), v3("p")),
+      lit3("passesArgument", v3("r"), v3("p"), v3("a"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedPassedTypedAs",
-    [v2("o"), v2("a"), v2("t")],
+    [v3("o"), v3("a"), v3("t")],
     [
-      lit2("wantedType", v2("o")),
-      lit2("refersToParam", v2("o"), v2("p")),
-      lit2("passesArgument", v2("r"), v2("p"), v2("a")),
-      lit2("typedAs", v2("a"), v2("t"))
+      lit3("wantedType", v3("o")),
+      lit3("refersToParam", v3("o"), v3("p")),
+      lit3("passesArgument", v3("r"), v3("p"), v3("a")),
+      lit3("typedAs", v3("a"), v3("t"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedPassedParam",
-    [v2("o"), v2("a")],
+    [v3("o"), v3("a")],
     [
-      lit2("wantedType", v2("o")),
-      lit2("refersToParam", v2("o"), v2("p")),
-      lit2("passesArgument", v2("r"), v2("p"), v2("a")),
-      lit2("refersToParam", v2("a"), v2("q"))
+      lit3("wantedType", v3("o")),
+      lit3("refersToParam", v3("o"), v3("p")),
+      lit3("passesArgument", v3("r"), v3("p"), v3("a")),
+      lit3("refersToParam", v3("a"), v3("q"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedComesFrom",
-    [v2("x"), v2("m"), v2("n")],
-    [lit2("wantedOrigin", v2("x")), lit2("comesFrom", v2("x"), v2("m"), v2("n"))]
+    [v3("x"), v3("m"), v3("n")],
+    [lit3("wantedOrigin", v3("x")), lit3("comesFrom", v3("x"), v3("m"), v3("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.
-  rule2("callOriginChain", [v2("x"), v2("x")], [lit2("wantedCallOrigin", v2("x"))]),
+  rule3("callOriginChain", [v3("x"), v3("x")], [lit3("wantedCallOrigin", v3("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.
-  rule2(
+  rule3(
     "callOriginChain",
-    [v2("x"), v2("z")],
-    [lit2("callOriginChainStepped", v2("x"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("callOriginChainStepped", v3("x"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "callOriginChainStepped",
-    [v2("x"), v2("z")],
-    [lit2("callOriginChain", v2("x"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("callOriginChain", v3("x"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "wantedCallOriginPair",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("callOriginChain", v2("x"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n"))
+      lit3("callOriginChain", v3("x"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n"))
     ]
   ),
   // An import of a project barrel is an import of what the barrel
   // forwards, so the pair surfaces the module behind the chain.
-  rule2(
+  rule3(
     "wantedCallOriginPair",
-    [v2("x"), v2("m2"), v2("n2")],
+    [v3("x"), v3("m2"), v3("n2")],
     [
-      lit2("callOriginChain", v2("x"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n")),
-      lit2("moduleForwards", v2("m"), v2("n"), v2("m2"), v2("n2"))
+      lit3("callOriginChain", v3("x"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n")),
+      lit3("moduleForwards", v3("m"), v3("n"), v3("m2"), v3("n2"))
     ]
   ),
   // A namespace member: the module's export of the member's own name.
   // The imports literal leads, since it is the smallest relation.
-  rule2(
+  rule3(
     "wantedCallOriginPair",
-    [v2("x"), v2("m"), v2("p")],
+    [v3("x"), v3("m"), v3("p")],
     [
-      lit2("imports", v2("o"), v2("m"), NAMESPACE_IMPORT),
-      lit2("readsProperty", v2("y"), v2("o"), v2("p")),
-      lit2("callOriginChain", v2("x"), v2("y"))
+      lit3("imports", v3("o"), v3("m"), NAMESPACE_IMPORT),
+      lit3("readsProperty", v3("y"), v3("o"), v3("p")),
+      lit3("callOriginChain", v3("x"), v3("y"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedCallOriginPair",
-    [v2("x"), v2("m"), v2("p")],
+    [v3("x"), v3("m"), v3("p")],
     [
-      lit2("imports", v2("d"), v2("m"), NAMESPACE_IMPORT),
-      lit2("binds", v2("o"), v2("d")),
-      lit2("readsProperty", v2("y"), v2("o"), v2("p")),
-      lit2("callOriginChain", v2("x"), v2("y"))
+      lit3("imports", v3("d"), v3("m"), NAMESPACE_IMPORT),
+      lit3("binds", v3("o"), v3("d")),
+      lit3("readsProperty", v3("y"), v3("o"), v3("p")),
+      lit3("callOriginChain", v3("x"), v3("y"))
     ]
   ),
   // What a call made: through the call to its callee, whose own alias
   // chain leads to the import.
-  rule2(
+  rule3(
     "callMadeChain",
-    [v2("x"), v2("f")],
-    [lit2("callOriginChain", v2("x"), v2("c")), lit2("call", v2("c"), v2("f"))]
+    [v3("x"), v3("f")],
+    [lit3("callOriginChain", v3("x"), v3("c")), lit3("call", v3("c"), v3("f"))]
   ),
-  rule2(
+  rule3(
     "callMadeChain",
-    [v2("x"), v2("z")],
-    [lit2("callMadeChain", v2("x"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("callMadeChain", v3("x"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "wantedCallOriginPair",
-    [v2("x"), v2("m"), v2("n")],
+    [v3("x"), v3("m"), v3("n")],
     [
-      lit2("callMadeChain", v2("x"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n"))
+      lit3("callMadeChain", v3("x"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n"))
     ]
   ),
   // A member destructured off what a call made keeps the member name
   // as one more path segment.
-  rule2(
+  rule3(
     "callMemberChain",
-    [v2("x"), v2("f"), v2("p")],
+    [v3("x"), v3("f"), v3("p")],
     [
-      lit2("callOriginChainStepped", v2("x"), v2("e")),
-      lit2("readsProperty", v2("e"), v2("c"), v2("p")),
-      lit2("call", v2("c"), v2("f"))
+      lit3("callOriginChainStepped", v3("x"), v3("e")),
+      lit3("readsProperty", v3("e"), v3("c"), v3("p")),
+      lit3("call", v3("c"), v3("f"))
     ]
   ),
-  rule2(
+  rule3(
     "callMemberChain",
-    [v2("x"), v2("z"), v2("p")],
+    [v3("x"), v3("z"), v3("p")],
     [
-      lit2("callMemberChain", v2("x"), v2("y"), v2("p")),
-      lit2("nameHop", v2("y"), v2("z"))
+      lit3("callMemberChain", v3("x"), v3("y"), v3("p")),
+      lit3("nameHop", v3("y"), v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedCallOriginMember",
-    [v2("x"), v2("m"), v2("n"), v2("p")],
+    [v3("x"), v3("m"), v3("n"), v3("p")],
     [
-      lit2("callMemberChain", v2("x"), v2("y"), v2("p")),
-      lit2("imports", v2("y"), v2("m"), v2("n"))
+      lit3("callMemberChain", v3("x"), v3("y"), v3("p")),
+      lit3("imports", v3("y"), v3("m"), v3("n"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedCallsInto",
-    [v2("g"), v2("m"), v2("n")],
+    [v3("g"), v3("m"), v3("n")],
     [
-      lit2("wantedOrigin", v2("x")),
-      lit2("comesTo", v2("x"), v2("g")),
-      lit2("callsInto", v2("g"), v2("m"), v2("n"))
+      lit3("wantedOrigin", v3("x")),
+      lit3("comesTo", v3("x"), v3("g")),
+      lit3("callsInto", v3("g"), v3("m"), v3("n"))
     ]
   ),
   // Subject identity, its own demand class; the README's subject
   // section says why the origin pair rides on the written-value walk.
-  rule2(
+  rule3(
     "wantedSubjectWritten",
-    [v2("x"), v2("r")],
-    [lit2("wantedSubject", v2("x")), lit2("isWrittenAs", v2("x"), v2("r"))]
+    [v3("x"), v3("r")],
+    [lit3("wantedSubject", v3("x")), lit3("isWrittenAs", v3("x"), v3("r"))]
   ),
-  rule2(
+  rule3(
     "wantedSubjectConstruction",
-    [v2("x"), v2("r"), v2("m"), v2("n")],
+    [v3("x"), v3("r"), v3("m"), v3("n")],
     [
-      lit2("wantedSubject", v2("x")),
-      lit2("isWrittenAs", v2("x"), v2("r")),
-      lit2("call", v2("r"), v2("c")),
-      lit2("comesFrom", v2("c"), v2("m"), v2("n"))
+      lit3("wantedSubject", v3("x")),
+      lit3("isWrittenAs", v3("x"), v3("r")),
+      lit3("call", v3("r"), v3("c")),
+      lit3("comesFrom", v3("c"), v3("m"), v3("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.
-  rule2(
+  rule3(
     "wantedModuleExport",
-    [v2("m"), v2("n"), v2("value")],
+    [v3("m"), v3("n"), v3("value")],
     [
-      lit2("wantedExportsOf", v2("m")),
-      lit2("moduleExport", v2("m"), v2("n"), v2("value"))
+      lit3("wantedExportsOf", v3("m")),
+      lit3("moduleExport", v3("m"), v3("n"), v3("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.
-  rule2("ancestryChain", [v2("c"), v2("c")], [lit2("wantedAncestry", v2("c"))]),
-  rule2(
+  rule3("ancestryChain", [v3("c"), v3("c")], [lit3("wantedAncestry", v3("c"))]),
+  rule3(
     "ancestryChain",
-    [v2("c"), v2("x")],
-    [lit2("ancestryChain", v2("c"), v2("b")), lit2("extends", v2("b"), v2("x"))]
+    [v3("c"), v3("x")],
+    [lit3("ancestryChain", v3("c"), v3("b")), lit3("extends", v3("b"), v3("x"))]
   ),
-  rule2(
+  rule3(
     "ancestryChain",
-    [v2("c"), v2("x")],
-    [lit2("ancestryChain", v2("c"), v2("b")), lit2("prepends", v2("b"), v2("x"))]
+    [v3("c"), v3("x")],
+    [lit3("ancestryChain", v3("c"), v3("b")), lit3("prepends", v3("b"), v3("x"))]
   ),
-  rule2(
+  rule3(
     "ancestryChain",
-    [v2("c"), v2("z")],
-    [lit2("ancestryChain", v2("c"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("c"), v3("z")],
+    [lit3("ancestryChain", v3("c"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "ancestryChain",
-    [v2("c"), v2("z")],
+    [v3("c"), v3("z")],
     [
-      lit2("ancestryChain", v2("c"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n")),
-      lit2("moduleExport", v2("m"), v2("n"), v2("z"))
+      lit3("ancestryChain", v3("c"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n")),
+      lit3("moduleExport", v3("m"), v3("n"), v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedBaseName",
-    [v2("c"), v2("n")],
-    [lit2("ancestryChain", v2("c"), v2("b")), lit2("extendsNamed", v2("b"), v2("n"))]
+    [v3("c"), v3("n")],
+    [lit3("ancestryChain", v3("c"), v3("b")), lit3("extendsNamed", v3("b"), v3("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.
-  rule2(
+  rule3(
     "wantedDeclaredName",
-    [v2("c"), v2("n")],
+    [v3("c"), v3("n")],
     [
-      lit2("ancestryChain", v2("c"), v2("b")),
-      lit2("holdsProperty", v2("b"), v2("n"), v2("held"))
+      lit3("ancestryChain", v3("c"), v3("b")),
+      lit3("holdsProperty", v3("b"), v3("n"), v3("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.
-  rule2(
+  rule3(
     "wantedDeclaredName",
-    [v2("c"), v2("n")],
-    [lit2("ancestryChain", v2("c"), v2("b")), lit2("declaresName", v2("b"), v2("n"))]
+    [v3("c"), v3("n")],
+    [lit3("ancestryChain", v3("c"), v3("b")), lit3("declaresName", v3("b"), v3("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.
-  rule2(
+  rule3(
     "wantedCallbackMethod",
-    [v2("c"), v2("event"), v2("n"), v2("held")],
+    [v3("c"), v3("event"), v3("n"), v3("held")],
     [
-      lit2("ancestryChain", v2("c"), v2("b")),
-      lit2("classCallback", v2("b"), v2("event"), v2("n")),
-      lit2("ancestryChain", v2("c"), v2("b2")),
-      lit2("holdsProperty", v2("b2"), v2("n"), v2("held"))
+      lit3("ancestryChain", v3("c"), v3("b")),
+      lit3("classCallback", v3("b"), v3("event"), v3("n")),
+      lit3("ancestryChain", v3("c"), v3("b2")),
+      lit3("holdsProperty", v3("b2"), v3("n"), v3("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.
-  rule2("anchorChain", [v2("x"), v2("x")], [lit2("wantedAnchor", v2("x"))]),
-  rule2(
+  rule3("anchorChain", [v3("x"), v3("x")], [lit3("wantedAnchor", v3("x"))]),
+  rule3(
     "anchorChain",
-    [v2("x"), v2("z")],
-    [lit2("anchorChain", v2("x"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("anchorChain", v3("x"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
-  rule2(
+  rule3(
     "anchorChain",
-    [v2("x"), v2("z")],
+    [v3("x"), v3("z")],
     [
-      lit2("anchorChain", v2("x"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n")),
-      lit2("moduleExport", v2("m"), v2("n"), v2("z"))
+      lit3("anchorChain", v3("x"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n")),
+      lit3("moduleExport", v3("m"), v3("n"), v3("z"))
     ]
   ),
-  rule2(
+  rule3(
     "anchorChain",
-    [v2("x"), v2("c")],
-    [lit2("anchorChain", v2("x"), v2("r")), lit2("call", v2("r"), v2("c"))]
+    [v3("x"), v3("c")],
+    [lit3("anchorChain", v3("x"), v3("r")), lit3("call", v3("r"), v3("c"))]
   ),
-  rule2(
+  rule3(
     "anchorChain",
-    [v2("x"), v2("o")],
+    [v3("x"), v3("o")],
     [
-      lit2("anchorChain", v2("x"), v2("y")),
-      lit2("readsProperty", v2("y"), v2("o"), v2("n"))
+      lit3("anchorChain", v3("x"), v3("y")),
+      lit3("readsProperty", v3("y"), v3("o"), v3("n"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedAnchorCall",
-    [v2("x"), v2("r")],
-    [lit2("anchorChain", v2("x"), v2("r")), lit2("call", v2("r"), v2("c"))]
+    [v3("x"), v3("r")],
+    [lit3("anchorChain", v3("x"), v3("r")), lit3("call", v3("r"), v3("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.
-  rule2("sourceChain", [v2("x"), v2("x")], [lit2("wantedSource", v2("x"))]),
+  rule3("sourceChain", [v3("x"), v3("x")], [lit3("wantedSource", v3("x"))]),
   ...SOURCE_STEPS.map(
-    (kind) => rule2(
+    (kind) => rule3(
       "sourceChain",
-      [v2("x"), v2("z")],
-      [lit2("sourceChain", v2("x"), v2("y")), lit2("hop", v2("y"), v2("z"), kind)]
+      [v3("x"), v3("z")],
+      [lit3("sourceChain", v3("x"), v3("y")), lit3("hop", v3("y"), v3("z"), kind)]
     )
   ),
   ...SOURCE_READS.map(
-    (read) => rule2(
+    (read) => rule3(
       "sourceChain",
-      [v2("x"), v2("o")],
-      [lit2("sourceChain", v2("x"), v2("y")), read]
+      [v3("x"), v3("o")],
+      [lit3("sourceChain", v3("x"), v3("y")), read]
     )
   ),
-  rule2(
+  rule3(
     "sourceChain",
-    [v2("x"), v2("a")],
+    [v3("x"), v3("a")],
     [
-      lit2("sourceChain", v2("x"), v2("r")),
-      lit2("converts", v2("r"), v2("a"), v2("n"))
+      lit3("sourceChain", v3("x"), v3("r")),
+      lit3("converts", v3("r"), v3("a"), v3("n"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedSourceConverts",
-    [v2("x"), v2("r"), v2("a"), v2("n")],
+    [v3("x"), v3("r"), v3("a"), v3("n")],
     [
-      lit2("sourceChain", v2("x"), v2("r")),
-      lit2("converts", v2("r"), v2("a"), v2("n"))
+      lit3("sourceChain", v3("x"), v3("r")),
+      lit3("converts", v3("r"), v3("a"), v3("n"))
     ]
   ),
-  rule2("inputChain", [v2("x"), v2("x")], [lit2("wantedInputRead", v2("x"))]),
-  rule2(
+  rule3("inputChain", [v3("x"), v3("x")], [lit3("wantedInputRead", v3("x"))]),
+  rule3(
     "inputChain",
-    [v2("x"), v2("z")],
-    [lit2("inputChain", v2("x"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("x"), v3("z")],
+    [lit3("inputChain", v3("x"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
   ...SOURCE_READS.map(
-    (read) => rule2(
+    (read) => rule3(
       "inputChain",
-      [v2("x"), v2("o")],
-      [lit2("inputChain", v2("x"), v2("y")), read]
+      [v3("x"), v3("o")],
+      [lit3("inputChain", v3("x"), v3("y")), read]
     )
   ),
-  rule2("sourceMember", [v2("x"), v2("y")], [lit2("sourceChain", v2("x"), v2("y"))]),
-  rule2("sourceMember", [v2("x"), v2("y")], [lit2("inputChain", v2("x"), v2("y"))]),
+  rule3("sourceMember", [v3("x"), v3("y")], [lit3("sourceChain", v3("x"), v3("y"))]),
+  rule3("sourceMember", [v3("x"), v3("y")], [lit3("inputChain", v3("x"), v3("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) => rule2(
+    (kind) => rule3(
       "wantedSourceHop",
-      [v2("x"), v2("y"), v2("z")],
-      [lit2("sourceChain", v2("x"), v2("y")), lit2("hop", v2("y"), v2("z"), kind)]
+      [v3("x"), v3("y"), v3("z")],
+      [lit3("sourceChain", v3("x"), v3("y")), lit3("hop", v3("y"), v3("z"), kind)]
     )
   ),
-  rule2(
+  rule3(
     "wantedSourceHop",
-    [v2("x"), v2("y"), v2("z")],
-    [lit2("inputChain", v2("x"), v2("y")), lit2("nameHop", v2("y"), v2("z"))]
+    [v3("x"), v3("y"), v3("z")],
+    [lit3("inputChain", v3("x"), v3("y")), lit3("nameHop", v3("y"), v3("z"))]
   ),
   ...WRITTEN_KEY_READS.map(
-    (read) => rule2(
+    (read) => rule3(
       "wantedSourceRead",
-      [v2("x"), v2("y"), v2("o"), v2("n")],
-      [lit2("sourceMember", v2("x"), v2("y")), read]
+      [v3("x"), v3("y"), v3("o"), v3("n")],
+      [lit3("sourceMember", v3("x"), v3("y")), read]
     )
   ),
-  rule2(
+  rule3(
     "wantedSourceKeyed",
-    [v2("x"), v2("y"), v2("o")],
+    [v3("x"), v3("y"), v3("o")],
     [
-      lit2("sourceMember", v2("x"), v2("y")),
-      lit2("readsKeyed", v2("y"), v2("o"), v2("k"))
+      lit3("sourceMember", v3("x"), v3("y")),
+      lit3("readsKeyed", v3("y"), v3("o"), v3("k"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedSourceParam",
-    [v2("x"), v2("p"), v2("f")],
+    [v3("x"), v3("p"), v3("f")],
     [
-      lit2("sourceMember", v2("x"), v2("p")),
-      lit2("paramOf", v2("f"), v2("k"), v2("p"))
+      lit3("sourceMember", v3("x"), v3("p")),
+      lit3("paramOf", v3("f"), v3("k"), v3("p"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedSourceParam",
-    [v2("x"), v2("p"), v2("f")],
+    [v3("x"), v3("p"), v3("f")],
     [
-      lit2("sourceMember", v2("x"), v2("p")),
-      lit2("paramNamed", v2("f"), v2("n"), v2("p"))
+      lit3("sourceMember", v3("x"), v3("p")),
+      lit3("paramNamed", v3("f"), v3("n"), v3("p"))
     ]
   ),
-  rule2(
+  rule3(
     "wantedSourceWritten",
-    [v2("x"), v2("w")],
-    [lit2("sourceMember", v2("x"), v2("w")), lit2("writtenValue", v2("w"))]
+    [v3("x"), v3("w")],
+    [lit3("sourceMember", v3("x"), v3("w")), lit3("writtenValue", v3("w"))]
   ),
-  rule2(
+  rule3(
     "wantedSourceCall",
-    [v2("x"), v2("r")],
-    [lit2("sourceMember", v2("x"), v2("r")), lit2("call", v2("r"), v2("c"))]
+    [v3("x"), v3("r")],
+    [lit3("sourceMember", v3("x"), v3("r")), lit3("call", v3("r"), v3("c"))]
   ),
-  rule2(
+  rule3(
     "wantedSourceImport",
-    [v2("x"), v2("y"), v2("m"), v2("n")],
+    [v3("x"), v3("y"), v3("m"), v3("n")],
     [
-      lit2("sourceMember", v2("x"), v2("y")),
-      lit2("imports", v2("y"), v2("m"), v2("n"))
+      lit3("sourceMember", v3("x"), v3("y")),
+      lit3("imports", v3("y"), v3("m"), v3("n"))
     ]
   )
 ];
@@ -5111,6 +5263,10 @@ export {
   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,
@@ -5150,6 +5306,8 @@ export {
   isObserved,
   isWrittenAsUnder,
   joinMountedPath,
+  keptVariants,
+  memberOf,
   mergeStoredDependencies,
   mountPathsOf,
   noDependencies,
@@ -5159,6 +5317,7 @@ export {
   objectOfUnder,
   observeDemand,
   packHashes,
+  plainKeyOf,
   proofRules,
   queryFacts,
   readDispatchOutcomes,
@@ -5168,6 +5327,8 @@ export {
   resolutionProgram,
   resolutionUnderProgram,
   resolvedFunctions,
+  selfFormOf,
+  selfResultOf,
   settledFunction,
   sourceLeavesOf,
   spanOfKey,
@@ -5177,6 +5338,7 @@ export {
   underQuestionSpend,
   unpackHashes,
   valueLeftByWrites,
+  variantKey,
   walkRecordsByFile,
   writesRunInOrder,
   writtenAnswersFor,