@suss/resolution 0.19.0 → 0.21.0

package/README.md

@@ -173,6 +173,59 @@ than a copy of every other. It differs from `callsFunction`, which
 starts from the function because a caller asking for call sites has the
 function in hand.
 
+## The anchor behind a receiver
+
+A pack sometimes wants a call handed back, not a yes or no. Mongoose is
+the picture: `model("User", schema)` is the anchor, and the pack reads
+the model name and the collection off that call's own arguments. The
+receiver in front of a matched method can be the model, a construction
+of it (`new User({...})`), or a document a query returned
+(`await User.findById(id)`), and each is a different number of hops
+from the anchor.
+
+`anchorChain` is the reachability that covers all three. From an asked
+value (`wantedAnchor`) it follows names (`binds`, `endsHolding`,
+`fallbackBranch`), imports through the export table, a call to its
+callee, and a method's callee to its receiver. Every call the chain
+passes lands in `wantedAnchorCall`, keyed by the asked value.
+
+Candidates, not one answer: the chain has no way to rank a nearer call
+above a farther one, and ranking inside the rules would be a depth
+bound in a new spelling. The asking side filters the candidates against
+its own origin (which module, which callee name) and applies the
+single-answer policy: exactly one distinct match is the anchor, none or
+several is a refusal.
+
+The demand cone stays on the base facts named above. Nothing here pulls
+`reaches` or `callsInto`, so asking about a receiver does not price in
+call-graph closure.
+
+## The subject behind a registration
+
+Discovery keeps asking one question: is this receiver the app, the
+router, the thing built by calling what a library exports? Which
+`.get(...)` calls are routes and which `.use(...)` calls are mounts
+both hang on the answer, and every language feature that moves a value
+is a place the receiver can be written: a class field, a destructured
+name, a property on an object another file built. Enumerating those
+spellings in a walker loses to the language, so the question is asked
+of the rules instead.
+
+The answer comes back in two relations, both seeded by
+`wantedSubject`.
+`wantedSubjectWritten` is the written-value walk from the asked
+receiver, so the asking side can apply the single-answer policy over
+everything the receiver could be. `wantedSubjectConstruction` keeps
+only the answers that are a call or a `new`, and pairs each with where
+its callee was imported from, through however many aliases the callee
+went. The asking side checks that pair against the (module, name) a
+pack declares: exactly one distinct construction with a matching
+origin is the subject, none or several is a refusal.
+
+The construction end needs no fact of its own. Every call is already a
+`call` fact, a `new` expression included, and the join against
+`comesFrom` is what makes one of them a subject seed.
+
 ## Explaining an answer
 
 Evaluate the same rules under `@suss/datalog`'s `witnesses` algebra and

package/dist/index.cjs

@@ -22,12 +22,17 @@ var index_exports = {};
 __export(index_exports, {
   ANSWER_RELATIONS: () => ANSWER_RELATIONS,
   FACT_CONTRACT_CASES: () => FACT_CONTRACT_CASES,
+  NAMESPACE_IMPORT: () => NAMESPACE_IMPORT,
+  NAMESPACE_IMPORT_NAME: () => NAMESPACE_IMPORT_NAME,
   RESOLUTION_QUESTIONS: () => RESOLUTION_QUESTIONS,
   RESOLUTION_RULES: () => RESOLUTION_RULES,
   RESULT_STEP: () => RESULT_STEP,
   VALUE_STEP: () => VALUE_STEP,
+  agreedMountPrefix: () => agreedMountPrefix,
   checkFactContract: () => checkFactContract,
   explainResolutionProof: () => explainResolutionProof,
+  joinMountedPath: () => joinMountedPath,
+  mountPathsOf: () => mountPathsOf,
   renderExplanation: () => renderExplanation
 });
 module.exports = __toCommonJS(index_exports);
@@ -461,9 +466,61 @@ function renderExplanation(explanation, describe) {
   return lines;
 }
 
+// src/mount.ts
+function joinMountedPath(prefix, path) {
+  const trimmed = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  return trimmed === "" ? path : trimmed + path;
+}
+function mountPathsOf(edges, childId) {
+  return pathsOf(edges, /* @__PURE__ */ new Map(), childId, /* @__PURE__ */ new Set());
+}
+function agreedMountPrefix(edges, childId) {
+  const paths = mountPathsOf(edges, childId);
+  if (paths === null) {
+    return null;
+  }
+  const distinct2 = new Set(paths);
+  const only = [...distinct2][0];
+  return distinct2.size === 1 && only !== void 0 ? only : null;
+}
+function pathsOf(edges, memo, childId, visiting) {
+  const cached = memo.get(childId);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (visiting.has(childId)) {
+    memo.set(childId, null);
+    return null;
+  }
+  const own = edges.get(childId);
+  if (own === void 0 || own.length === 0) {
+    memo.set(childId, [""]);
+    return [""];
+  }
+  visiting.add(childId);
+  const composed = /* @__PURE__ */ new Set();
+  let unstated = false;
+  for (const edge of own) {
+    const parentPaths = pathsOf(edges, memo, edge.parentId, visiting);
+    if (parentPaths === null) {
+      unstated = true;
+      break;
+    }
+    for (const parentPath of parentPaths) {
+      composed.add(joinMountedPath(parentPath, edge.prefix));
+    }
+  }
+  visiting.delete(childId);
+  const result = unstated ? null : [...composed];
+  memo.set(childId, result);
+  return result;
+}
+
 // src/index.ts
 var import_datalog2 = require("@suss/datalog");
 var VALUE_STEP = (0, import_datalog2.constant)("value");
+var NAMESPACE_IMPORT_NAME = "*";
+var NAMESPACE_IMPORT = (0, import_datalog2.constant)(NAMESPACE_IMPORT_NAME);
 var RESULT_STEP = (0, import_datalog2.constant)("result");
 var RESOLUTION_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
@@ -683,6 +740,21 @@ var RESOLUTION_RULES = [
       (0, import_datalog2.lit)("callKeywordArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("a"))
     ]
   ),
+  // Which module's export a re-exported name forwards to, however
+  // many barrels deep the forwarding runs.
+  (0, import_datalog2.rule)(
+    "moduleForwards",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")],
+    [(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.rule)(
+    "moduleForwards",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m3"), (0, import_datalog2.variable)("n3")],
+    [
+      (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)("moduleForwards", (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"), (0, import_datalog2.variable)("m3"), (0, import_datalog2.variable)("n3"))
+    ]
+  ),
   // What a module exports: directly, or through re-export chains.
   (0, import_datalog2.rule)(
     "moduleExport",
@@ -862,15 +934,9 @@ var RESOLUTION_RULES = [
       (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
-  // is f's own body, including the closures it declares; the other hop
-  // is a function f's body calls, so a wrapper of a wrapper answers
-  // with what the innermost one reaches.
-  //
-  // Several answers for one function is the normal case, not an
-  // ambiguity: a project decorator that composes two library decorators
-  // applies both. A caller asks whether a particular (m, n) is among
-  // them.
+  // Calling f ends up calling the name n that module m exports, one
+  // hop through f's own body or deeper through a wrapper of a wrapper.
+  // Several results is normal: a composed decorator applies them all.
   (0, import_datalog2.rule)(
     "callsInto",
     [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
@@ -938,6 +1004,155 @@ var RESOLUTION_QUESTIONS = [
     [(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"))]
   ),
+  // Call-origin questions, for attribution, in their own demand
+  // class. Attribution stops at the import declaration, so nothing
+  // here demands reaches or callsInto. The chains are closures with
+  // no depth bound: an alias run of any length resolves.
+  (0, import_datalog2.rule)("callOriginChain", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("wantedCallOrigin", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  // The chain with at least one hop taken, which is what tells a
+  // destructured binding apart from asking about a node directly.
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
+  // An import of a project barrel is an import of what the barrel
+  // forwards, so the pair surfaces the module behind the chain.
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("moduleForwards", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"))
+    ]
+  ),
+  // A namespace member: the module's export of the member's own name.
+  // The imports literal leads, since it is the smallest relation.
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("d"), (0, import_datalog2.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("d")),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))
+    ]
+  ),
+  // What a call made: through the call to its callee, whose own alias
+  // chain leads to the import.
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("f")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("c")), (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
+  // A member destructured off what a call made keeps the member name
+  // as one more path segment.
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callOriginChainStepped", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("e")),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("e"), (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginMember",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
   (0, import_datalog2.rule)(
     "wantedCallsInto",
     [(0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
@@ -946,6 +1161,98 @@ var RESOLUTION_QUESTIONS = [
       (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"))
     ]
+  ),
+  // Subject identity, its own demand class; the README's subject
+  // section says why the origin pair rides on the written-value walk.
+  (0, import_datalog2.rule)(
+    "wantedSubjectWritten",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")],
+    [(0, import_datalog2.lit)("wantedSubject", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("isWrittenAs", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r"))]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedSubjectConstruction",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("wantedSubject", (0, import_datalog2.variable)("x")),
+      (0, import_datalog2.lit)("isWrittenAs", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")),
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (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"))
+    ]
+  ),
+  // The export table of one module, keyed by the module asked about.
+  // The moduleExport rules flatten re-export chains of any length, and
+  // the demand cone stays on export facts alone.
+  (0, import_datalog2.rule)(
+    "wantedModuleExport",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value")],
+    [
+      (0, import_datalog2.lit)("wantedExportsOf", (0, import_datalog2.variable)("m")),
+      (0, import_datalog2.lit)("moduleExport", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("value"))
+    ]
+  ),
+  // 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.
+  // A class's ancestry, one hop per extends through the binding that
+  // says which class the written base is; the names on the way out
+  // are what a storage pack matches its library's bases against.
+  (0, import_datalog2.rule)("ancestryChain", [(0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("c")], [(0, import_datalog2.lit)("wantedAncestry", (0, import_datalog2.variable)("c"))]),
+  (0, import_datalog2.rule)(
+    "ancestryChain",
+    [(0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("b2")],
+    [
+      (0, import_datalog2.lit)("ancestryChain", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("b")),
+      (0, import_datalog2.lit)("extends", (0, import_datalog2.variable)("b"), (0, import_datalog2.variable)("x")),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("b2"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedBaseName",
+    [(0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("n")],
+    [(0, import_datalog2.lit)("ancestryChain", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("b")), (0, import_datalog2.lit)("extendsNamed", (0, import_datalog2.variable)("b"), (0, import_datalog2.variable)("n"))]
+  ),
+  (0, import_datalog2.rule)("anchorChain", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("wantedAnchor", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (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)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("c")],
+    [(0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")), (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c"))]
+  ),
+  (0, import_datalog2.rule)(
+    "anchorChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("o")],
+    [
+      (0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedAnchorCall",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")],
+    [(0, import_datalog2.lit)("anchorChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")), (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("c"))]
   )
 ];
 var ANSWER_RELATIONS = [
@@ -955,11 +1262,16 @@ var ANSWER_RELATIONS = [
 0 && (module.exports = {
   ANSWER_RELATIONS,
   FACT_CONTRACT_CASES,
+  NAMESPACE_IMPORT,
+  NAMESPACE_IMPORT_NAME,
   RESOLUTION_QUESTIONS,
   RESOLUTION_RULES,
   RESULT_STEP,
   VALUE_STEP,
+  agreedMountPrefix,
   checkFactContract,
   explainResolutionProof,
+  joinMountedPath,
+  mountPathsOf,
   renderExplanation
 });

package/dist/index.d.cts

@@ -105,8 +105,59 @@ declare function explainResolutionProof(proof: Proof, options: ExplainOptions):
  */
 declare function renderExplanation(explanation: ResolutionExplanation, describe: DescribeAtom): string[];
 
+/**
+ * Mount composition, shared between adapters. An adapter states one
+ * fact per mount call, `mounted(child, parent, prefix)`, however its
+ * language spells the call: Express's `app.use(prefix, router)`,
+ * FastAPI's `app.include_router(router, prefix=...)`. This module
+ * composes those edges into the full prefix a child's routes are
+ * served under, so both adapters compute the same paths.
+ *
+ * The composition is a function over the edge set rather than a
+ * datalog rule because a rule head cannot build a new atom, and a
+ * path-concatenating closure would not terminate on a mount cycle:
+ * the string grows on every round. Here a cycle is an abstention.
+ */
+interface MountEdge {
+    parentId: string;
+    prefix: string;
+}
+/** Every mount edge, keyed by the mounted child. */
+type MountEdges = ReadonlyMap<string, readonly MountEdge[]>;
+/**
+ * Join a mount prefix onto a path written with its own leading slash.
+ * A root prefix strips to nothing, so mounting under "/" leaves the
+ * path as written.
+ */
+declare function joinMountedPath(prefix: string, path: string): string;
+/**
+ * Every full prefix the child's mount chains compose to, one per
+ * mount, which is what one-boundary-per-mount reads. Null when a
+ * chain cannot be stated: a cycle, or an ancestor whose own paths
+ * cannot be stated. An unmounted child composes to [""].
+ */
+declare function mountPathsOf(edges: MountEdges, childId: string): readonly string[] | null;
+/**
+ * The one prefix every mount chain agrees on. "" for an unmounted
+ * child, null when a cycle or a disagreement leaves nothing to say.
+ *
+ * Agreement is checked on the composed result, not the literal prefix
+ * a mount call gives: two mounts spelling the identical local prefix
+ * still land at different full paths when one parent is itself
+ * mounted somewhere the other is not.
+ */
+declare function agreedMountPrefix(edges: MountEdges, childId: string): string | null;
+
 /** A step to the value x is written as. */
 declare const VALUE_STEP: _suss_datalog.Term;
+/**
+ * The name a whole-module import records itself under, whatever the
+ * language spells it as: `import * as ns` in TypeScript, `import
+ * module` in Python. Adapters emit this name; the member-read rule
+ * joins on it.
+ */
+declare const NAMESPACE_IMPORT_NAME = "*";
+declare const NAMESPACE_IMPORT: _suss_datalog.Term;
 /** A step to what running the call x is handed back. */
 declare const RESULT_STEP: _suss_datalog.Term;
 /**
@@ -145,4 +196,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, FACT_CONTRACT_CASES, type FactsOf, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type StepContext, type StepPhrase, VALUE_STEP, checkFactContract, explainResolutionProof, renderExplanation };
+export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type StepContext, type StepPhrase, VALUE_STEP, agreedMountPrefix, checkFactContract, explainResolutionProof, joinMountedPath, mountPathsOf, renderExplanation };

package/dist/index.d.ts

@@ -105,8 +105,59 @@ declare function explainResolutionProof(proof: Proof, options: ExplainOptions):
  */
 declare function renderExplanation(explanation: ResolutionExplanation, describe: DescribeAtom): string[];
 
+/**
+ * Mount composition, shared between adapters. An adapter states one
+ * fact per mount call, `mounted(child, parent, prefix)`, however its
+ * language spells the call: Express's `app.use(prefix, router)`,
+ * FastAPI's `app.include_router(router, prefix=...)`. This module
+ * composes those edges into the full prefix a child's routes are
+ * served under, so both adapters compute the same paths.
+ *
+ * The composition is a function over the edge set rather than a
+ * datalog rule because a rule head cannot build a new atom, and a
+ * path-concatenating closure would not terminate on a mount cycle:
+ * the string grows on every round. Here a cycle is an abstention.
+ */
+interface MountEdge {
+    parentId: string;
+    prefix: string;
+}
+/** Every mount edge, keyed by the mounted child. */
+type MountEdges = ReadonlyMap<string, readonly MountEdge[]>;
+/**
+ * Join a mount prefix onto a path written with its own leading slash.
+ * A root prefix strips to nothing, so mounting under "/" leaves the
+ * path as written.
+ */
+declare function joinMountedPath(prefix: string, path: string): string;
+/**
+ * Every full prefix the child's mount chains compose to, one per
+ * mount, which is what one-boundary-per-mount reads. Null when a
+ * chain cannot be stated: a cycle, or an ancestor whose own paths
+ * cannot be stated. An unmounted child composes to [""].
+ */
+declare function mountPathsOf(edges: MountEdges, childId: string): readonly string[] | null;
+/**
+ * The one prefix every mount chain agrees on. "" for an unmounted
+ * child, null when a cycle or a disagreement leaves nothing to say.
+ *
+ * Agreement is checked on the composed result, not the literal prefix
+ * a mount call gives: two mounts spelling the identical local prefix
+ * still land at different full paths when one parent is itself
+ * mounted somewhere the other is not.
+ */
+declare function agreedMountPrefix(edges: MountEdges, childId: string): string | null;
+
 /** A step to the value x is written as. */
 declare const VALUE_STEP: _suss_datalog.Term;
+/**
+ * The name a whole-module import records itself under, whatever the
+ * language spells it as: `import * as ns` in TypeScript, `import
+ * module` in Python. Adapters emit this name; the member-read rule
+ * joins on it.
+ */
+declare const NAMESPACE_IMPORT_NAME = "*";
+declare const NAMESPACE_IMPORT: _suss_datalog.Term;
 /** A step to what running the call x is handed back. */
 declare const RESULT_STEP: _suss_datalog.Term;
 /**
@@ -145,4 +196,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, FACT_CONTRACT_CASES, type FactsOf, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type StepContext, type StepPhrase, VALUE_STEP, checkFactContract, explainResolutionProof, renderExplanation };
+export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type StepContext, type StepPhrase, VALUE_STEP, agreedMountPrefix, checkFactContract, explainResolutionProof, joinMountedPath, mountPathsOf, renderExplanation };

package/dist/index.js

@@ -427,9 +427,61 @@ function renderExplanation(explanation, describe) {
   return lines;
 }
 
+// src/mount.ts
+function joinMountedPath(prefix, path) {
+  const trimmed = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  return trimmed === "" ? path : trimmed + path;
+}
+function mountPathsOf(edges, childId) {
+  return pathsOf(edges, /* @__PURE__ */ new Map(), childId, /* @__PURE__ */ new Set());
+}
+function agreedMountPrefix(edges, childId) {
+  const paths = mountPathsOf(edges, childId);
+  if (paths === null) {
+    return null;
+  }
+  const distinct2 = new Set(paths);
+  const only = [...distinct2][0];
+  return distinct2.size === 1 && only !== void 0 ? only : null;
+}
+function pathsOf(edges, memo, childId, visiting) {
+  const cached = memo.get(childId);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (visiting.has(childId)) {
+    memo.set(childId, null);
+    return null;
+  }
+  const own = edges.get(childId);
+  if (own === void 0 || own.length === 0) {
+    memo.set(childId, [""]);
+    return [""];
+  }
+  visiting.add(childId);
+  const composed = /* @__PURE__ */ new Set();
+  let unstated = false;
+  for (const edge of own) {
+    const parentPaths = pathsOf(edges, memo, edge.parentId, visiting);
+    if (parentPaths === null) {
+      unstated = true;
+      break;
+    }
+    for (const parentPath of parentPaths) {
+      composed.add(joinMountedPath(parentPath, edge.prefix));
+    }
+  }
+  visiting.delete(childId);
+  const result = unstated ? null : [...composed];
+  memo.set(childId, result);
+  return result;
+}
+
 // src/index.ts
 import { constant, lit, rule, variable as v } from "@suss/datalog";
 var VALUE_STEP = constant("value");
+var NAMESPACE_IMPORT_NAME = "*";
+var NAMESPACE_IMPORT = constant(NAMESPACE_IMPORT_NAME);
 var RESULT_STEP = constant("result");
 var RESOLUTION_RULES = [
   // Aliasing: const x = y, or an identifier referencing a declaration.
@@ -649,6 +701,21 @@ var RESOLUTION_RULES = [
       lit("callKeywordArg", v("r"), v("n"), v("a"))
     ]
   ),
+  // Which module's export a re-exported name forwards to, however
+  // many barrels deep the forwarding runs.
+  rule(
+    "moduleForwards",
+    [v("m"), v("n"), v("m2"), v("n2")],
+    [lit("reExports", v("m"), v("n"), v("m2"), v("n2"))]
+  ),
+  rule(
+    "moduleForwards",
+    [v("m"), v("n"), v("m3"), v("n3")],
+    [
+      lit("reExports", v("m"), v("n"), v("m2"), v("n2")),
+      lit("moduleForwards", v("m2"), v("n2"), v("m3"), v("n3"))
+    ]
+  ),
   // What a module exports: directly, or through re-export chains.
   rule(
     "moduleExport",
@@ -828,15 +895,9 @@ var RESOLUTION_RULES = [
       lit("imports", v("y"), v("m"), v("n"))
     ]
   ),
-  // Calling f ends up calling the name n that module m exports. One hop
-  // is f's own body, including the closures it declares; the other hop
-  // is a function f's body calls, so a wrapper of a wrapper answers
-  // with what the innermost one reaches.
-  //
-  // Several answers for one function is the normal case, not an
-  // ambiguity: a project decorator that composes two library decorators
-  // applies both. A caller asks whether a particular (m, n) is among
-  // them.
+  // 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.
   rule(
     "callsInto",
     [v("f"), v("m"), v("n")],
@@ -904,6 +965,155 @@ var RESOLUTION_QUESTIONS = [
     [v("x"), v("m"), v("n")],
     [lit("wantedOrigin", v("x")), lit("comesFrom", v("x"), v("m"), v("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.
+  rule("callOriginChain", [v("x"), v("x")], [lit("wantedCallOrigin", v("x"))]),
+  rule(
+    "callOriginChain",
+    [v("x"), v("z")],
+    [lit("callOriginChain", v("x"), v("y")), lit("binds", v("y"), v("z"))]
+  ),
+  rule(
+    "callOriginChain",
+    [v("x"), v("z")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("endsHolding", v("y"), v("z"))
+    ]
+  ),
+  rule(
+    "callOriginChain",
+    [v("x"), v("z")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("fallbackBranch", v("y"), v("z"))
+    ]
+  ),
+  // The chain with at least one hop taken, which is what tells a
+  // destructured binding apart from asking about a node directly.
+  rule(
+    "callOriginChainStepped",
+    [v("x"), v("z")],
+    [lit("callOriginChain", v("x"), v("y")), lit("binds", v("y"), v("z"))]
+  ),
+  rule(
+    "callOriginChainStepped",
+    [v("x"), v("z")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("endsHolding", v("y"), v("z"))
+    ]
+  ),
+  rule(
+    "callOriginChainStepped",
+    [v("x"), v("z")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("fallbackBranch", v("y"), v("z"))
+    ]
+  ),
+  rule(
+    "wantedCallOriginPair",
+    [v("x"), v("m"), v("n")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("imports", v("y"), v("m"), v("n"))
+    ]
+  ),
+  // An import of a project barrel is an import of what the barrel
+  // forwards, so the pair surfaces the module behind the chain.
+  rule(
+    "wantedCallOriginPair",
+    [v("x"), v("m2"), v("n2")],
+    [
+      lit("callOriginChain", v("x"), v("y")),
+      lit("imports", v("y"), v("m"), v("n")),
+      lit("moduleForwards", v("m"), v("n"), v("m2"), v("n2"))
+    ]
+  ),
+  // A namespace member: the module's export of the member's own name.
+  // The imports literal leads, since it is the smallest relation.
+  rule(
+    "wantedCallOriginPair",
+    [v("x"), v("m"), v("p")],
+    [
+      lit("imports", v("o"), v("m"), NAMESPACE_IMPORT),
+      lit("readsProperty", v("y"), v("o"), v("p")),
+      lit("callOriginChain", v("x"), v("y"))
+    ]
+  ),
+  rule(
+    "wantedCallOriginPair",
+    [v("x"), v("m"), v("p")],
+    [
+      lit("imports", v("d"), v("m"), NAMESPACE_IMPORT),
+      lit("binds", v("o"), v("d")),
+      lit("readsProperty", v("y"), v("o"), v("p")),
+      lit("callOriginChain", v("x"), v("y"))
+    ]
+  ),
+  // What a call made: through the call to its callee, whose own alias
+  // chain leads to the import.
+  rule(
+    "callMadeChain",
+    [v("x"), v("f")],
+    [lit("callOriginChain", v("x"), v("c")), lit("call", v("c"), v("f"))]
+  ),
+  rule(
+    "callMadeChain",
+    [v("x"), v("z")],
+    [lit("callMadeChain", v("x"), v("y")), lit("binds", v("y"), v("z"))]
+  ),
+  rule(
+    "callMadeChain",
+    [v("x"), v("z")],
+    [lit("callMadeChain", v("x"), v("y")), lit("endsHolding", v("y"), v("z"))]
+  ),
+  rule(
+    "wantedCallOriginPair",
+    [v("x"), v("m"), v("n")],
+    [
+      lit("callMadeChain", v("x"), v("y")),
+      lit("imports", v("y"), v("m"), v("n"))
+    ]
+  ),
+  // A member destructured off what a call made keeps the member name
+  // as one more path segment.
+  rule(
+    "callMemberChain",
+    [v("x"), v("f"), v("p")],
+    [
+      lit("callOriginChainStepped", v("x"), v("e")),
+      lit("readsProperty", v("e"), v("c"), v("p")),
+      lit("call", v("c"), v("f"))
+    ]
+  ),
+  rule(
+    "callMemberChain",
+    [v("x"), v("z"), v("p")],
+    [
+      lit("callMemberChain", v("x"), v("y"), v("p")),
+      lit("binds", v("y"), v("z"))
+    ]
+  ),
+  rule(
+    "callMemberChain",
+    [v("x"), v("z"), v("p")],
+    [
+      lit("callMemberChain", v("x"), v("y"), v("p")),
+      lit("endsHolding", v("y"), v("z"))
+    ]
+  ),
+  rule(
+    "wantedCallOriginMember",
+    [v("x"), v("m"), v("n"), v("p")],
+    [
+      lit("callMemberChain", v("x"), v("y"), v("p")),
+      lit("imports", v("y"), v("m"), v("n"))
+    ]
+  ),
   rule(
     "wantedCallsInto",
     [v("g"), v("m"), v("n")],
@@ -912,6 +1122,98 @@ var RESOLUTION_QUESTIONS = [
       lit("comesTo", v("x"), v("g")),
       lit("callsInto", v("g"), v("m"), v("n"))
     ]
+  ),
+  // Subject identity, its own demand class; the README's subject
+  // section says why the origin pair rides on the written-value walk.
+  rule(
+    "wantedSubjectWritten",
+    [v("x"), v("r")],
+    [lit("wantedSubject", v("x")), lit("isWrittenAs", v("x"), v("r"))]
+  ),
+  rule(
+    "wantedSubjectConstruction",
+    [v("x"), v("r"), v("m"), v("n")],
+    [
+      lit("wantedSubject", v("x")),
+      lit("isWrittenAs", v("x"), v("r")),
+      lit("call", v("r"), v("c")),
+      lit("comesFrom", v("c"), v("m"), v("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.
+  rule(
+    "wantedModuleExport",
+    [v("m"), v("n"), v("value")],
+    [
+      lit("wantedExportsOf", v("m")),
+      lit("moduleExport", v("m"), v("n"), v("value"))
+    ]
+  ),
+  // 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.
+  // A class's ancestry, one hop per extends through the binding that
+  // says which class the written base is; the names on the way out
+  // are what a storage pack matches its library's bases against.
+  rule("ancestryChain", [v("c"), v("c")], [lit("wantedAncestry", v("c"))]),
+  rule(
+    "ancestryChain",
+    [v("c"), v("b2")],
+    [
+      lit("ancestryChain", v("c"), v("b")),
+      lit("extends", v("b"), v("x")),
+      lit("binds", v("x"), v("b2"))
+    ]
+  ),
+  rule(
+    "wantedBaseName",
+    [v("c"), v("n")],
+    [lit("ancestryChain", v("c"), v("b")), lit("extendsNamed", v("b"), v("n"))]
+  ),
+  rule("anchorChain", [v("x"), v("x")], [lit("wantedAnchor", v("x"))]),
+  rule(
+    "anchorChain",
+    [v("x"), v("z")],
+    [lit("anchorChain", v("x"), v("y")), lit("binds", v("y"), v("z"))]
+  ),
+  rule(
+    "anchorChain",
+    [v("x"), v("z")],
+    [lit("anchorChain", v("x"), v("y")), lit("endsHolding", v("y"), v("z"))]
+  ),
+  rule(
+    "anchorChain",
+    [v("x"), v("z")],
+    [lit("anchorChain", v("x"), v("y")), lit("fallbackBranch", v("y"), v("z"))]
+  ),
+  rule(
+    "anchorChain",
+    [v("x"), v("z")],
+    [
+      lit("anchorChain", v("x"), v("y")),
+      lit("imports", v("y"), v("m"), v("n")),
+      lit("moduleExport", v("m"), v("n"), v("z"))
+    ]
+  ),
+  rule(
+    "anchorChain",
+    [v("x"), v("c")],
+    [lit("anchorChain", v("x"), v("r")), lit("call", v("r"), v("c"))]
+  ),
+  rule(
+    "anchorChain",
+    [v("x"), v("o")],
+    [
+      lit("anchorChain", v("x"), v("y")),
+      lit("readsProperty", v("y"), v("o"), v("n"))
+    ]
+  ),
+  rule(
+    "wantedAnchorCall",
+    [v("x"), v("r")],
+    [lit("anchorChain", v("x"), v("r")), lit("call", v("r"), v("c"))]
   )
 ];
 var ANSWER_RELATIONS = [
@@ -920,11 +1222,16 @@ var ANSWER_RELATIONS = [
 export {
   ANSWER_RELATIONS,
   FACT_CONTRACT_CASES,
+  NAMESPACE_IMPORT,
+  NAMESPACE_IMPORT_NAME,
   RESOLUTION_QUESTIONS,
   RESOLUTION_RULES,
   RESULT_STEP,
   VALUE_STEP,
+  agreedMountPrefix,
   checkFactContract,
   explainResolutionProof,
+  joinMountedPath,
+  mountPathsOf,
   renderExplanation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/resolution",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "type": "module",
   "description": "Language-neutral rules for following a value to the function it comes down to.",
   "keywords": [
@@ -53,6 +53,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@suss/datalog": "0.19.0"
+    "@suss/datalog": "0.21.0"
   }
 }