@suss/resolution 0.10.0 → 0.12.0

package/dist/index.cjs

@@ -26,7 +26,9 @@ __export(index_exports, {
   RESOLUTION_RULES: () => RESOLUTION_RULES,
   RESULT_STEP: () => RESULT_STEP,
   VALUE_STEP: () => VALUE_STEP,
-  checkFactContract: () => checkFactContract
+  checkFactContract: () => checkFactContract,
+  explainResolutionProof: () => explainResolutionProof,
+  renderExplanation: () => renderExplanation
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -145,6 +147,27 @@ var FACT_CONTRACT_CASES = [
       return facts("callArg").length > 0 ? null : "a construction passes its argument nowhere, so the parameter it lands in has no value";
     }
   },
+  {
+    name: "a name declared as a fallback",
+    requires: "a module-level name declared as a fallback between a property read and a call, `cached || build()` say",
+    // The fallback expression states its branches; each branch has to be
+    // keyed as the value node itself, or the chain stops at the fallback
+    // instead of continuing into whichever branch resolves.
+    check: (facts) => {
+      const branches = facts("fallbackBranch");
+      if (branches.length < 2) {
+        return `expected a fallback with two branches, found ${branches.length}`;
+      }
+      if (distinct(branches.map((row) => row[0] ?? "")) !== 1) {
+        return "the two branches are keyed under different expressions, so nothing says they are alternatives for one value";
+      }
+      const call = facts("call")[0]?.[0];
+      if (call === void 0) {
+        return "the call branch is not written down as a call, so the branch that resolves has nothing behind it";
+      }
+      return branches.some((row) => row[1] === call) ? null : "no branch is the call node itself, so the chain cannot continue into the branch that resolves";
+    }
+  },
   {
     name: "a value another file declares",
     requires: "two files, one declaring a value and the other reading it by name",
@@ -202,283 +225,544 @@ function checkFactContract(sources, emit, options = {}) {
   }, Promise.resolve([]));
 }
 
-// src/index.ts
+// src/explain.ts
 var import_datalog = require("@suss/datalog");
-var VALUE_STEP = (0, import_datalog.constant)("value");
-var RESULT_STEP = (0, import_datalog.constant)("result");
+function exportTrail(proof, describe) {
+  if (proof.kind !== "derived") {
+    return [];
+  }
+  const name = (0, import_datalog.ruleLabel)(proof.rule);
+  if (name === "re-export") {
+    const [m, n, m2, n2] = proof.premises[0].tuple;
+    return [
+      `${describe(m)} takes ${String(n)} from ${describe(m2)}, where it is called ${String(n2)}`,
+      ...exportTrail(proof.premises[1], describe)
+    ];
+  }
+  if (name === "re-export all") {
+    const [m, m2] = proof.premises[0].tuple;
+    return [
+      `${describe(m)} forwards everything ${describe(m2)} exports`,
+      ...exportTrail(proof.premises[1], describe)
+    ];
+  }
+  return [];
+}
+function argumentReason(proof, describe) {
+  const [, p, a] = proof.tuple;
+  if (proof.kind !== "derived") {
+    return `${describe(p)} is a parameter, and a call passes it ${describe(a)}`;
+  }
+  const f = proof.premises[0].tuple[0];
+  return `${describe(p)} is a parameter of ${describe(f)}, and a call passes it ${describe(a)}`;
+}
+var DEFAULT_PHRASES = {
+  alias: ({ tuple, describe }) => ({
+    reason: `${describe(tuple[0])} is declared as ${describe(tuple[1])}`
+  }),
+  "last write": ({ tuple, describe }) => ({
+    reason: `${describe(tuple[0])} is written more than once, and the last write leaves it as ${describe(tuple[1])}`
+  }),
+  fallback: ({ tuple, describe }) => ({
+    reason: `${describe(tuple[0])} is a fallback expression, and ${describe(tuple[1])} is the branch that resolves`
+  }),
+  import: ({ tuple, premises, describe }) => {
+    const [, module2, name] = premises[0].tuple;
+    return {
+      reason: `${describe(tuple[0])} is imported from ${describe(module2)} under the name ${String(name)}`,
+      notes: exportTrail(premises[1], describe)
+    };
+  },
+  argument: ({ premises, describe }) => ({
+    reason: argumentReason(premises[0], describe)
+  }),
+  "property read": ({ tuple, premises, describe }) => {
+    const [, object, name] = premises[0].tuple;
+    const contains = premises[2];
+    const inherited = contains.kind === "derived" && contains.premises.length > 1;
+    return {
+      reason: `${describe(tuple[0])} reads ${String(name)} off ${describe(object)}, which contains ${describe(tuple[1])}`,
+      notes: inherited ? [`${String(name)} comes from a base class`] : []
+    };
+  },
+  "class instance": ({ tuple, premises, describe, inline }) => ({
+    reason: `${describe(tuple[0])} makes an instance of ${describe(tuple[1])}`,
+    notes: inline(premises[1])
+  }),
+  "factory unwrap": ({ tuple, premises, describe, inline }) => {
+    const factory = premises[1].tuple[1];
+    return {
+      reason: `${describe(tuple[0])} calls ${describe(factory)}, a factory that passes its argument through, so it comes down to ${describe(tuple[1])}`,
+      notes: inline(premises[1])
+    };
+  },
+  "declared wrapper": ({ tuple, premises, describe }) => {
+    const callee = String(premises[0].tuple[1]);
+    const module2 = String(premises[2].tuple[1]);
+    const argument = String(premises[1].tuple[1]);
+    return {
+      reason: `${describe(tuple[0])} calls ${callee} from ${module2}, which passes argument ${argument} through, so it comes down to ${describe(tuple[1])}`,
+      assumptions: [
+        `a pack declares that ${callee} from ${module2} passes argument ${argument} through to its result`
+      ]
+    };
+  },
+  "call result": ({ tuple, premises, describe, inline }) => {
+    const invokes = premises[0];
+    const invoked = invokes.tuple[1];
+    const calleeWalks = invokes.kind === "derived" ? invokes.premises.filter(
+      (premise) => premise.kind === "derived" && (premise.relation === "comesTo" || premise.relation === "givesBack")
+    ) : [];
+    return {
+      reason: `${describe(tuple[0])} runs ${describe(invoked)}, which returns ${describe(tuple[1])}`,
+      notes: calleeWalks.flatMap((premise) => inline(premise))
+    };
+  }
+};
+var CHAIN_RELATIONS = /* @__PURE__ */ new Set([
+  "resolves",
+  "comesTo",
+  "givesBack",
+  "isWrittenAs",
+  "comesFrom",
+  "reaches",
+  "stepsTo"
+]);
+function inlineChain(proof, state) {
+  const explained = explainResolutionProof(proof, {
+    describe: state.describe,
+    phrases: state.phrases
+  });
+  if (explained === null || explained.steps.length === 0) {
+    return [];
+  }
+  if (explained.truncated) {
+    state.truncated = true;
+  }
+  return explained.steps.map((step) => step.reason);
+}
+function stepFrom(proof, state) {
+  const name = (0, import_datalog.ruleLabel)(proof.rule);
+  const phrase = state.phrases[name];
+  const from = proof.tuple[0];
+  const to = proof.tuple[1];
+  if (phrase === void 0) {
+    return {
+      from,
+      to,
+      rule: name,
+      reason: `${state.describe(from)} steps to ${state.describe(to)} (${name})`,
+      notes: [],
+      assumptions: []
+    };
+  }
+  const said = phrase({
+    tuple: proof.tuple,
+    premises: proof.premises,
+    describe: state.describe,
+    inline: (nested) => inlineChain(nested, state)
+  });
+  return {
+    from,
+    to,
+    rule: name,
+    reason: said.reason,
+    notes: said.notes ?? [],
+    assumptions: said.assumptions ?? []
+  };
+}
+function importStep(proof, state) {
+  const [x, module2, name] = proof.tuple;
+  return {
+    from: x,
+    to: module2,
+    rule: "import",
+    reason: `${state.describe(x)} is imported from ${state.describe(module2)} under the name ${String(name)}`,
+    notes: [],
+    assumptions: []
+  };
+}
+var flattenInto = (proof, state) => {
+  if (proof.kind === "truncated") {
+    state.truncated = true;
+    return;
+  }
+  if (proof.kind !== "derived") {
+    return;
+  }
+  const relation = proof.relation;
+  if (relation === "stepsTo") {
+    state.steps.push(stepFrom(proof, state));
+    return;
+  }
+  if (relation === "reaches") {
+    for (const p of proof.premises) {
+      flattenInto(p, state);
+    }
+    return;
+  }
+  if (relation === "comesFrom") {
+    if (proof.premises.length === 2) {
+      flattenInto(proof.premises[0], state);
+      state.steps.push(importStep(proof.premises[1], state));
+    } else {
+      state.steps.push(importStep(proof.premises[0], state));
+    }
+    return;
+  }
+  for (const p of proof.premises) {
+    if (p.kind === "derived" && (p.relation === "reaches" || p.relation === "comesTo")) {
+      flattenInto(p, state);
+    }
+    if (p.kind === "truncated") {
+      state.truncated = true;
+    }
+  }
+};
+function explainResolutionProof(proof, options) {
+  if (proof.kind === "absence") {
+    return null;
+  }
+  if (proof.kind === "derived" && !CHAIN_RELATIONS.has(proof.relation)) {
+    return null;
+  }
+  const state = {
+    steps: [],
+    truncated: proof.kind === "truncated",
+    describe: options.describe,
+    phrases: { ...DEFAULT_PHRASES, ...options.phrases }
+  };
+  flattenInto(proof, state);
+  const atoms = proof.kind === "fact" || proof.kind === "truncated" ? [proof.tuple[0]] : [proof.tuple[0], ...state.steps.map((step) => step.to)];
+  return {
+    atoms,
+    steps: state.steps,
+    assumptions: state.steps.flatMap((step) => step.assumptions),
+    truncated: state.truncated
+  };
+}
+function renderExplanation(explanation, describe) {
+  const lines = [];
+  if (explanation.steps.length > 0) {
+    lines.push(explanation.atoms.map((atom) => describe(atom)).join(" -> "));
+  }
+  for (const step of explanation.steps) {
+    lines.push(`  ${step.reason}`);
+    for (const note of step.notes) {
+      lines.push(`    ${note}`);
+    }
+  }
+  for (const assumption of explanation.assumptions) {
+    lines.push(`  assuming ${assumption}`);
+  }
+  if (explanation.truncated) {
+    lines.push("  the chain goes on past the proof depth cap");
+  }
+  return lines;
+}
+
+// src/index.ts
+var import_datalog2 = require("@suss/datalog");
+var VALUE_STEP = (0, import_datalog2.constant)("value");
+var RESULT_STEP = (0, import_datalog2.constant)("result");
 var RESOLUTION_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
   // A language with a hop of its own, like JavaScript's `.bind`, states
   // it as a step too, or every question but `comesTo` misses it.
-  (0, import_datalog.rule)("stepsTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP], [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"))]),
+  (0, import_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP],
+    [(0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))],
+    "alias"
+  ),
   // A name written more than once has the value the last write left
   // there. The adapter works out which write that is and stays quiet
   // when control flow decides, so such a name steps nowhere at all.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP],
+    [(0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))],
+    "last write"
+  ),
+  // A fallback says the value is one of its branches, so each branch is
+  // a step. A branch that resolves to nothing makes no claim, and two
+  // branches resolving to different things fail the single-answer policy.
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP],
-    [(0, import_datalog.lit)("endsHolding", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("b"), VALUE_STEP],
+    [(0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("b"))],
+    "fallback"
   ),
   // An import steps to what the module exports under that name.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("value"), VALUE_STEP],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("value"), VALUE_STEP],
     [
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value"))
-    ]
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value"))
+    ],
+    "import"
   ),
   // A parameter steps to what a call passes it. A function called from
   // several places leaves its parameter with more than one value, and a
   // caller that needs those apart asks `paramAt`.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("a"), VALUE_STEP],
-    [(0, import_datalog.lit)("passesArgument", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a"))]
+    [(0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("a"), VALUE_STEP],
+    [(0, import_datalog2.lit)("passesArgument", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("a"))],
+    "argument"
   ),
   // Reading a property steps to what the object contains under that
   // name, whichever way the object arrived: `routes.list` off a name,
   // or `make(body).handle` off a call.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("held"), VALUE_STEP],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("held"), VALUE_STEP],
     [
-      (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("o"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")),
-      (0, import_datalog.lit)("contains", (0, import_datalog.variable)("obj"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held"))
-    ]
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("objectOf", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("obj")),
+      (0, import_datalog2.lit)("contains", (0, import_datalog2.variable)("obj"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("held"))
+    ],
+    "property read"
   ),
   // Calling a class makes one of it, so the call steps to the class and
   // a method read off the result is the one the class declares. The
   // caveat below is about a factory function, and a class is not one.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("cls"), VALUE_STEP],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("cls"), VALUE_STEP],
     [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("cls")),
-      (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("cls"))
-    ]
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("cls")),
+      (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("cls"))
+    ],
+    "class instance"
   ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("a"), VALUE_STEP],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("unwraps", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
-    ]
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("unwraps", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")),
+      (0, import_datalog2.lit)("callArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("a"))
+    ],
+    "factory unwrap"
   ),
   // Wrapper transparency, declared: a pack says this callee wraps
   // argument k. The callee has to come from the library the pack said,
   // so a local object spelled the same way is not mistaken for it.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("a"), VALUE_STEP],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("a"), VALUE_STEP],
     [
-      (0, import_datalog.lit)("calleeName", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("unwrapsByName", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("k")),
-      (0, import_datalog.lit)("wrapperModule", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("m")),
-      (0, import_datalog.lit)("calleeOrigin", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("m")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
-    ]
+      (0, import_datalog2.lit)("calleeName", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("unwrapsByName", (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("k")),
+      (0, import_datalog2.lit)("wrapperModule", (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m")),
+      (0, import_datalog2.lit)("calleeOrigin", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("m")),
+      (0, import_datalog2.lit)("callArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("a"))
+    ],
+    "declared wrapper"
   ),
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "stepsTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("ret"), RESULT_STEP],
-    [(0, import_datalog.lit)("invokes", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")), (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("ret"))]
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("ret"), RESULT_STEP],
+    [(0, import_datalog2.lit)("invokes", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")), (0, import_datalog2.lit)("returnsValue", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("ret"))],
+    "call result"
   ),
   // Where a walk gets to, and whether it ran a call on the way. A value
   // step keeps whatever the rest of the walk was, and a result step
   // makes the whole walk one that ran a call.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "reaches",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind")],
-    [(0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind")],
+    [(0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "reaches",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind")],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind")],
     [
-      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP),
-      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind"))
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP),
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind"))
     ]
   ),
   // Two rules rather than one leaving the rest of the walk's kind free.
   // A free kind is a second question about the same relation, and a
   // demand-driven run then derives both to answer either.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "reaches",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), RESULT_STEP),
-      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), VALUE_STEP)
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), VALUE_STEP)
     ]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "reaches",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), RESULT_STEP),
-      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), RESULT_STEP)
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), RESULT_STEP)
     ]
   ),
   // What a value comes down to: the walk that never ran a call, stopped
   // at a function or an object. Something already written out comes to
   // itself, and every other walk ends at one of those.
-  (0, import_datalog.rule)("comesTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("func", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)("comesTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)("comesTo", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("func", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)("comesTo", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)(
     "comesTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), VALUE_STEP), (0, import_datalog2.lit)("func", (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "comesTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), VALUE_STEP), (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("z"))]
   ),
   // The same stopping condition, for the walk that ran a call. A call
   // gets no `comesTo` answer on purpose: coming back with what a
   // factory returned would fight the unwrapping answer.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "givesBack",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP), (0, import_datalog2.lit)("func", (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "givesBack",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP), (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("z"))]
   ),
   // Following a value to the expression it is written as, whatever kind
   // that is. A GraphQL document is neither a function nor an object, so
   // `comesTo` never reaches one.
-  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("writtenValue", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)("isWrittenAs", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("writtenValue", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)("isWrittenAs", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)(
     "isWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("writtenValue", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), VALUE_STEP), (0, import_datalog2.lit)("writtenValue", (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "isWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), VALUE_STEP), (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("z"))]
   ),
   // What one call site put in a parameter, told apart from what the
   // other callers passed.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "paramAt",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("z")],
     [
-      (0, import_datalog.lit)("passesArgument", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("z"))
+      (0, import_datalog2.lit)("passesArgument", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("a")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("a"), (0, import_datalog2.variable)("z"))
     ]
   ),
   // An argument arriving at the parameter it is passed to, by position
   // or by the name the caller wrote, keeping the call it went through
   // so `paramAt` can tell two call sites apart.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "passesArgument",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("a")],
     [
-      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
+      (0, import_datalog2.lit)("paramOf", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callsFunction", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("callArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("a"))
     ]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "passesArgument",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("a")],
     [
-      (0, import_datalog.lit)("paramNamed", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("callKeywordArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("a"))
+      (0, import_datalog2.lit)("paramNamed", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callsFunction", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("callKeywordArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("a"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "moduleExport",
-    [(0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value")],
-    [(0, import_datalog.lit)("exportsAs", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value"))]
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value")],
+    [(0, import_datalog2.lit)("exportsAs", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value"))],
+    "export"
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "moduleExport",
-    [(0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value")],
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value")],
     [
-      (0, import_datalog.lit)("reExports", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n2")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n2"), (0, import_datalog.variable)("value"))
-    ]
+      (0, import_datalog2.lit)("reExports", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")),
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"), (0, import_datalog2.variable)("value"))
+    ],
+    "re-export"
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "moduleExport",
-    [(0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value")],
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value")],
     [
-      (0, import_datalog.lit)("reExportsAll", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("m2")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value"))
-    ]
+      (0, import_datalog2.lit)("reExportsAll", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("m2")),
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value"))
+    ],
+    "re-export all"
   ),
   // The function a call runs, written from the call's side because a
   // caller asking what a call gives back has the call in hand.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "invokes",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
-    [(0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f"))]
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
+    [(0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c")), (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))]
   ),
   // The callee is itself a call: `daoBuilder()()`.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "invokes",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
-    [(0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")), (0, import_datalog.lit)("givesBack", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f"))]
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
+    [(0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c")), (0, import_datalog2.lit)("givesBack", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))]
   ),
   // The object an expression refers to: a name through `comesTo`, a
   // factory call through what it gives back. Naming the step is what
   // makes `routes.list` and `make(body).handle` one rule.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "objectOf",
-    [(0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")],
-    [(0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("obj"))]
+    [(0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("obj")],
+    [(0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("obj")), (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("obj"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "objectOf",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("obj")],
-    [(0, import_datalog.lit)("givesBack", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("obj")), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("obj"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("obj")],
+    [(0, import_datalog2.lit)("givesBack", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("obj")), (0, import_datalog2.lit)("objectValue", (0, import_datalog2.variable)("obj"))]
   ),
   // Which calls a function, found by the name the call is written as
   // rather than by resolving every callee in the project. A caller knows
   // the function and wants its call sites, so both of these start from
   // the function. Starting from `call` instead asks what every call in
   // the project imports, which was 72% of everything derived.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "callsFunction",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
-    [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")), (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c"))]
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
+    [(0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f")), (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "callsFunction",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
     [
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c"))
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c"))
     ]
   ),
   // The same, for a language whose adapter writes the import down as a
   // declaration and the call's callee as the name referring to it.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "callsFunction",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
     [
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("d"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("binds", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("d")),
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c"))
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("d"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("d")),
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c"))
     ]
   ),
   // What an object contains, its base class included, so a method the base
@@ -486,47 +770,47 @@ var RESOLUTION_RULES = [
   // declare gives two, and the caller decides. This is its own relation
   // rather than more `holdsProperty`, which stays something an adapter
   // states and the rules only read.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "contains",
-    [(0, import_datalog.variable)("o"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held")],
-    [(0, import_datalog.lit)("holdsProperty", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held"))]
+    [(0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("held")],
+    [(0, import_datalog2.lit)("holdsProperty", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("held"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "contains",
-    [(0, import_datalog.variable)("cls"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held")],
+    [(0, import_datalog2.variable)("cls"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("held")],
     [
-      (0, import_datalog.lit)("extends", (0, import_datalog.variable)("cls"), (0, import_datalog.variable)("base")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("base"), (0, import_datalog.variable)("baseCls")),
-      (0, import_datalog.lit)("contains", (0, import_datalog.variable)("baseCls"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held"))
+      (0, import_datalog2.lit)("extends", (0, import_datalog2.variable)("cls"), (0, import_datalog2.variable)("base")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("base"), (0, import_datalog2.variable)("baseCls")),
+      (0, import_datalog2.lit)("contains", (0, import_datalog2.variable)("baseCls"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("held"))
     ]
   ),
   // Which function a factory returns, and which of its parameters that
   // function calls: together they are what makes it a wrapper.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "returnsFunc",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("g")],
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("g")],
     [
-      (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("value")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("value"), (0, import_datalog.variable)("g")),
-      (0, import_datalog.lit)("func", (0, import_datalog.variable)("g"))
+      (0, import_datalog2.lit)("returnsValue", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("value")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("value"), (0, import_datalog2.variable)("g")),
+      (0, import_datalog2.lit)("func", (0, import_datalog2.variable)("g"))
     ]
   ),
   // A call made by a nested closure counts as made by the function
   // that declares it; the closure runs as part of that function.
-  (0, import_datalog.rule)("bodyCallsDeep", [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("c")], [(0, import_datalog.lit)("bodyCalls", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("c"))]),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)("bodyCallsDeep", [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("c")], [(0, import_datalog2.lit)("bodyCalls", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("c"))]),
+  (0, import_datalog2.rule)(
     "bodyCallsDeep",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("c")],
-    [(0, import_datalog.lit)("containsFn", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("g")), (0, import_datalog.lit)("bodyCallsDeep", (0, import_datalog.variable)("g"), (0, import_datalog.variable)("c"))]
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("c")],
+    [(0, import_datalog2.lit)("containsFn", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("g")), (0, import_datalog2.lit)("bodyCallsDeep", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("c"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "unwraps",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")],
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")],
     [
-      (0, import_datalog.lit)("returnsFunc", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("g")),
-      (0, import_datalog.lit)("bodyCallsDeep", (0, import_datalog.variable)("g"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("binds", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p"))
+      (0, import_datalog2.lit)("returnsFunc", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("g")),
+      (0, import_datalog2.lit)("bodyCallsDeep", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("paramOf", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("p"))
     ]
   ),
   // Argument flow: which parameter a value traces back to. Directly
@@ -534,48 +818,48 @@ var RESOLUTION_RULES = [
   // another unwrapping factory. This is what lets
   // `createProtected(h) { return service.withAuth(h); }` unwrap:
   // the returned call passes h through withAuth, which unwraps.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "flowsToParam",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("p")],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("p")],
     [
-      (0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("anyF"), (0, import_datalog.variable)("anyK"), (0, import_datalog.variable)("p"))
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("paramOf", (0, import_datalog2.variable)("anyF"), (0, import_datalog2.variable)("anyK"), (0, import_datalog2.variable)("p"))
     ]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "flowsToParam",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p")],
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p")],
     [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("unwraps", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("flowsToParam", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("p"))
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f")),
+      (0, import_datalog2.lit)("unwraps", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")),
+      (0, import_datalog2.lit)("callArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("a")),
+      (0, import_datalog2.lit)("flowsToParam", (0, import_datalog2.variable)("a"), (0, import_datalog2.variable)("p"))
     ]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "unwraps",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")],
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")],
     [
-      (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("value")),
-      (0, import_datalog.lit)("flowsToParam", (0, import_datalog.variable)("value"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p"))
+      (0, import_datalog2.lit)("returnsValue", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("value")),
+      (0, import_datalog2.lit)("flowsToParam", (0, import_datalog2.variable)("value"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("paramOf", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k"), (0, import_datalog2.variable)("p"))
     ]
   ),
   // Where a name comes from, when what it refers to lives outside the
   // source being read. A walk ends at something written out in source,
   // so it never reaches a library's own function.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "comesFrom",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
-    [(0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [(0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "comesFrom",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
     [
-      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP),
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   ),
   // Calling f ends up calling the name n that module m exports. One hop
@@ -587,80 +871,80 @@ var RESOLUTION_RULES = [
   // ambiguity: a project decorator that composes two library decorators
   // applies both. A caller asks whether a particular (m, n) is among
   // them.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "callsInto",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
     [
-      (0, import_datalog.lit)("bodyCallsDeep", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesFrom", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
+      (0, import_datalog2.lit)("bodyCallsDeep", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("comesFrom", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "callsInto",
-    [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
     [
-      (0, import_datalog.lit)("bodyCallsDeep", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("g")),
-      (0, import_datalog.lit)("callsInto", (0, import_datalog.variable)("g"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
+      (0, import_datalog2.lit)("bodyCallsDeep", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("c")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("g")),
+      (0, import_datalog2.lit)("callsInto", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   ),
   // The question callers ask: what a value comes to, narrowed to the
   // functions. Objects appear in the middle of chains and never in an
   // answer.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "resolves",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")), (0, import_datalog2.lit)("func", (0, import_datalog2.variable)("z"))]
   )
 ];
 var RESOLUTION_QUESTIONS = [
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedResolves",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("resolves", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wanted", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("resolves", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedComesTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wanted", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedComesTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wantedOrigin", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wantedOrigin", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedIsWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("isWrittenAs", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wanted", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("isWrittenAs", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"))]
   ),
   // A call is given no `comesTo`, so this is the only way to ask what
   // object one arrives at, and without it a demand-driven run derives
   // `objectOf` nowhere.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedObjectOf",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wanted", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("objectOf", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"))]
   ),
   // Keyed by the parameter, since that is what a caller has in hand
   // when it wants the call sites told apart.
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedParamAt",
-    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("r"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("p")), (0, import_datalog.lit)("paramAt", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("wanted", (0, import_datalog2.variable)("p")), (0, import_datalog2.lit)("paramAt", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.variable)("z"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedComesFrom",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
-    [(0, import_datalog.lit)("wantedOrigin", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("comesFrom", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))]
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [(0, import_datalog2.lit)("wantedOrigin", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("comesFrom", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))]
   ),
-  (0, import_datalog.rule)(
+  (0, import_datalog2.rule)(
     "wantedCallsInto",
-    [(0, import_datalog.variable)("g"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
+    [(0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
     [
-      (0, import_datalog.lit)("wantedOrigin", (0, import_datalog.variable)("x")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("g")),
-      (0, import_datalog.lit)("callsInto", (0, import_datalog.variable)("g"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
+      (0, import_datalog2.lit)("wantedOrigin", (0, import_datalog2.variable)("x")),
+      (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("g")),
+      (0, import_datalog2.lit)("callsInto", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   )
 ];
@@ -675,5 +959,7 @@ var ANSWER_RELATIONS = [
   RESOLUTION_RULES,
   RESULT_STEP,
   VALUE_STEP,
-  checkFactContract
+  checkFactContract,
+  explainResolutionProof,
+  renderExplanation
 });