@suss/adapter-python 0.10.0 → 0.12.0

package/README.md

@@ -6,7 +6,7 @@ The Python language adapter for suss. It parses source with tree-sitter (WASM),
 
 `@suss/adapter-python` is the Python language adapter. It meets the Layer 1 contract in [`docs/internal/facts-and-rules.md`](../../../docs/internal/facts-and-rules.md): discover units, emit summaries in the shared IR, emit facts. It parses a file with `web-tree-sitter` and a vendored Python grammar (`grammar/tree-sitter-python.wasm`, so there is no native build step), builds module, class and function scopes over the tree (imports, assignments, `global`/`nonlocal`), works out which file in the repo an import points at, and finds routes on decorated functions and class methods whose decorator resolves to a module the pack was configured with. When a pack says the library mounts routers (FastAPI's `APIRouter` plus `include_router`), the adapter builds a route's path out of the two literal prefixes, one mount hop deep. When it cannot build the path, the route keeps its name, gets no path, and gets a gap explaining why. Each unit it finds becomes a `RawCodeStructure` object, which it hands to `assembleSummary` in `@suss/extractor`, the same assembly code the TypeScript adapter uses.
 
-v0 (this slice) does nothing with the path engine. A route either has no transitions at all, or one transition that describes the response the code declares (a FastAPI `response_model` / `status_code`, or a return annotation). It never breaks a route into branches. See [`docs/internal/proposals/language-adapters.md`](../../../docs/internal/proposals/language-adapters.md) for what a later slice adds.
+v0 (this slice) does nothing with the path engine. A route either has no transitions at all, or one transition that describes the response the code declares (a FastAPI `response_model` / `status_code`, or a return annotation). It never breaks a route into branches. See [`design/proposals/language-adapters.md`](../../../design/proposals/language-adapters.md) for what a later slice adds.
 
 ## Where it fits in suss
 

package/dist/index.cjs

@@ -15747,7 +15747,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-HBAMPBAO.js
+// ../../ir-core/dist/chunk-AQYS5AC6.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -16049,6 +16049,9 @@ function normalizePath(path4) {
   );
   return normalized;
 }
+function pathShape(path4) {
+  return normalizePath(path4).replace(/\{[^}]*\}/g, "{}");
+}
 function methodsAgree(a, b) {
   if (a === null || b === null) {
     return false;
@@ -16100,12 +16103,17 @@ var restSemantics = defineBoundarySemantics({
      * settles it inside the bucket. The identity key stays what a reader
      * sees and a suppression targets ("GET /users", "* /users"), and
      * this key groups what a reader still tells apart.
+     *
+     * A parameter's name goes too. A spec written by hand says
+     * `{userId}` where the Express route that serves it says `:id`, and
+     * both match the same requests, so pairing on the name gave two
+     * boundaries that never met and a run with nothing to report.
      */
     pairingKey(semantics) {
       if (semantics.method === null || semantics.path === null) {
         return null;
       }
-      return `rest ${normalizePath(semantics.path)}`;
+      return `rest ${pathShape(semantics.path)}`;
     },
     sidesAgree(a, b) {
       return methodsAgree(a.method, b.method);
@@ -16481,285 +16489,311 @@ function statementIn(call) {
 }
 
 // src/facts/resolve.ts
-var import_datalog2 = require("@suss/datalog");
+var import_datalog3 = require("@suss/datalog");
 
 // ../../resolution/dist/index.js
 var import_datalog = require("@suss/datalog");
-var VALUE_STEP = (0, import_datalog.constant)("value");
-var RESULT_STEP = (0, import_datalog.constant)("result");
+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
@@ -16767,47 +16801,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
@@ -16815,48 +16849,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
@@ -16868,80 +16902,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"))
     ]
   )
 ];
@@ -16950,7 +16984,7 @@ var ANSWER_RELATIONS = [
 ];
 
 // src/facts/resolve.ts
-var RESOLUTION_PROGRAM = (0, import_datalog2.deriveOnDemand)(
+var RESOLUTION_PROGRAM = (0, import_datalog3.deriveOnDemand)(
   [...RESOLUTION_RULES, ...RESOLUTION_QUESTIONS],
   ANSWER_RELATIONS
 );
@@ -16961,7 +16995,7 @@ function resolveCalls(db, callKeys) {
   for (const callKey of callKeys) {
     db.add("wanted", [callKey]);
   }
-  (0, import_datalog2.evaluate)(db, RESOLUTION_PROGRAM.rules);
+  (0, import_datalog3.evaluate)(db, RESOLUTION_PROGRAM.rules);
 }
 function containedValues(db, objectKey) {
   return db.facts("holdsProperty").filter((row) => row[0] === objectKey).map((row) => [String(row[1]), String(row[2])]).sort(([left], [right]) => Number(left) - Number(right)).map(([, value]) => value);
@@ -18536,7 +18570,7 @@ async function parsePython(source) {
 // src/project.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
-var import_datalog3 = require("@suss/datalog");
+var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
 
 // src/routers.ts
@@ -19486,7 +19520,7 @@ function reportUnresolvedProjectModules(options) {
   }
 }
 async function extractPythonProject(options) {
-  const db = new import_datalog3.Database();
+  const db = new import_datalog4.Database();
   const summaries = [];
   const gapHandling = options.gapHandling ?? "permissive";
   const displayPathOf = (file2) => options.workspaceRoot !== void 0 ? import_node_path3.default.relative(options.workspaceRoot, file2) : file2;

package/dist/index.js

@@ -15703,7 +15703,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-HBAMPBAO.js
+// ../../ir-core/dist/chunk-AQYS5AC6.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -16005,6 +16005,9 @@ function normalizePath(path4) {
   );
   return normalized;
 }
+function pathShape(path4) {
+  return normalizePath(path4).replace(/\{[^}]*\}/g, "{}");
+}
 function methodsAgree(a, b) {
   if (a === null || b === null) {
     return false;
@@ -16056,12 +16059,17 @@ var restSemantics = defineBoundarySemantics({
      * settles it inside the bucket. The identity key stays what a reader
      * sees and a suppression targets ("GET /users", "* /users"), and
      * this key groups what a reader still tells apart.
+     *
+     * A parameter's name goes too. A spec written by hand says
+     * `{userId}` where the Express route that serves it says `:id`, and
+     * both match the same requests, so pairing on the name gave two
+     * boundaries that never met and a run with nothing to report.
      */
     pairingKey(semantics) {
       if (semantics.method === null || semantics.path === null) {
         return null;
       }
-      return `rest ${normalizePath(semantics.path)}`;
+      return `rest ${pathShape(semantics.path)}`;
     },
     sidesAgree(a, b) {
       return methodsAgree(a.method, b.method);
@@ -16440,6 +16448,7 @@ function statementIn(call) {
 import { deriveOnDemand, evaluate } from "@suss/datalog";
 
 // ../../resolution/dist/index.js
+import { ruleLabel } from "@suss/datalog";
 import { constant, lit, rule, variable as v } from "@suss/datalog";
 var VALUE_STEP = constant("value");
 var RESULT_STEP = constant("result");
@@ -16447,14 +16456,29 @@ 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.
-  rule("stepsTo", [v("x"), v("y"), VALUE_STEP], [lit("binds", v("x"), v("y"))]),
+  rule(
+    "stepsTo",
+    [v("x"), v("y"), VALUE_STEP],
+    [lit("binds", v("x"), v("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.
   rule(
     "stepsTo",
     [v("x"), v("y"), VALUE_STEP],
-    [lit("endsHolding", v("x"), v("y"))]
+    [lit("endsHolding", v("x"), v("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.
+  rule(
+    "stepsTo",
+    [v("x"), v("b"), VALUE_STEP],
+    [lit("fallbackBranch", v("x"), v("b"))],
+    "fallback"
   ),
   // An import steps to what the module exports under that name.
   rule(
@@ -16463,7 +16487,8 @@ var RESOLUTION_RULES = [
     [
       lit("imports", v("x"), v("m"), v("n")),
       lit("moduleExport", v("m"), v("n"), v("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
@@ -16471,7 +16496,8 @@ var RESOLUTION_RULES = [
   rule(
     "stepsTo",
     [v("p"), v("a"), VALUE_STEP],
-    [lit("passesArgument", v("r"), v("p"), v("a"))]
+    [lit("passesArgument", v("r"), v("p"), v("a"))],
+    "argument"
   ),
   // Reading a property steps to what the object contains under that
   // name, whichever way the object arrived: `routes.list` off a name,
@@ -16483,7 +16509,8 @@ var RESOLUTION_RULES = [
       lit("readsProperty", v("x"), v("o"), v("n")),
       lit("objectOf", v("o"), v("obj")),
       lit("contains", v("obj"), v("n"), v("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
@@ -16495,7 +16522,8 @@ var RESOLUTION_RULES = [
       lit("call", v("r"), v("c")),
       lit("comesTo", v("c"), v("cls")),
       lit("objectValue", v("cls"))
-    ]
+    ],
+    "class instance"
   ),
   // Wrapper transparency, derived: calling a factory that returns a
   // function which calls its parameter k steps to argument k.
@@ -16507,7 +16535,8 @@ var RESOLUTION_RULES = [
       lit("comesTo", v("c"), v("f")),
       lit("unwraps", v("f"), v("k")),
       lit("callArg", v("r"), v("k"), v("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,
@@ -16521,14 +16550,16 @@ var RESOLUTION_RULES = [
       lit("wrapperModule", v("n"), v("m")),
       lit("calleeOrigin", v("r"), v("m")),
       lit("callArg", v("r"), v("k"), v("a"))
-    ]
+    ],
+    "declared wrapper"
   ),
   // The one step that runs a function forwards: a call steps to what
   // the function it invokes returns.
   rule(
     "stepsTo",
     [v("r"), v("ret"), RESULT_STEP],
-    [lit("invokes", v("r"), v("f")), lit("returnsValue", v("f"), v("ret"))]
+    [lit("invokes", v("r"), v("f")), lit("returnsValue", v("f"), v("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
@@ -16643,7 +16674,8 @@ var RESOLUTION_RULES = [
   rule(
     "moduleExport",
     [v("m"), v("n"), v("value")],
-    [lit("exportsAs", v("m"), v("n"), v("value"))]
+    [lit("exportsAs", v("m"), v("n"), v("value"))],
+    "export"
   ),
   rule(
     "moduleExport",
@@ -16651,7 +16683,8 @@ var RESOLUTION_RULES = [
     [
       lit("reExports", v("m"), v("n"), v("m2"), v("n2")),
       lit("moduleExport", v("m2"), v("n2"), v("value"))
-    ]
+    ],
+    "re-export"
   ),
   rule(
     "moduleExport",
@@ -16659,7 +16692,8 @@ var RESOLUTION_RULES = [
     [
       lit("reExportsAll", v("m"), v("m2")),
       lit("moduleExport", v("m2"), v("n"), v("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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/adapter-python",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "type": "module",
   "description": "Python language adapter for suss — parses source with tree-sitter (WASM), resolves names with a lexical binder, and emits raw extractions for the suss pipeline.",
   "keywords": [
@@ -47,10 +47,10 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@suss/behavioral-ir": "0.10.0",
-    "@suss/datalog": "0.10.0",
-    "@suss/extractor": "0.10.0",
-    "@suss/sql": "0.10.0",
+    "@suss/behavioral-ir": "0.12.0",
+    "@suss/datalog": "0.12.0",
+    "@suss/extractor": "0.12.0",
+    "@suss/sql": "0.12.0",
     "web-tree-sitter": "^0.26.11"
   },
   "devDependencies": {