@suss/adapter-ruby 0.18.0 → 0.20.0

package/dist/index.cjs

@@ -63,6 +63,9 @@ function rangeOf(node) {
     end: node.endPosition.row + 1
   };
 }
+function spanOf(node) {
+  return { start: node.startIndex, end: node.endIndex };
+}
 function field(node, name) {
   return node.childForFieldName(name);
 }
@@ -782,6 +785,9 @@ function invocationEffects(definitionNode) {
   });
 }
 
+// src/storage.ts
+var import_datalog3 = require("@suss/datalog");
+
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -1462,8 +1468,8 @@ function assertNever(_x) {
 function assert(_) {
 }
 function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v2]) => v2);
   return values;
 }
 function joinValues(array2, separator = "|") {
@@ -1517,9 +1523,9 @@ function defineLazy(object2, key, getter) {
       }
       return value;
     },
-    set(v) {
+    set(v2) {
       Object.defineProperty(object2, key, {
-        value: v
+        value: v2
         // configurable: true,
       });
     },
@@ -3206,10 +3212,10 @@ var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
       v7: 7,
       v8: 8
     };
-    const v = versionMap[def.version];
-    if (v === void 0)
+    const v2 = versionMap[def.version];
+    if (v2 === void 0)
       throw new Error(`Invalid UUID version: "${def.version}"`);
-    def.pattern ?? (def.pattern = uuid(v));
+    def.pattern ?? (def.pattern = uuid(v2));
   } else
     def.pattern ?? (def.pattern = uuid());
   $ZodStringFormat.init(inst, def);
@@ -3814,8 +3820,8 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
       const field2 = shape[key]._zod;
       if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field2.values)
-          propValues[key].add(v);
+        for (const v2 of field2.values)
+          propValues[key].add(v2);
       }
     }
     return propValues;
@@ -4110,10 +4116,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       const pv = option._zod.propValues;
       if (!pv || Object.keys(pv).length === 0)
         throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
-      for (const [k, v] of Object.entries(pv)) {
+      for (const [k, v2] of Object.entries(pv)) {
         if (!propValues[k])
           propValues[k] = /* @__PURE__ */ new Set();
-        for (const val of v) {
+        for (const val of v2) {
           propValues[k].add(val);
         }
       }
@@ -4127,11 +4133,11 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       const values = o._zod.propValues?.[def.discriminator];
       if (!values || values.size === 0)
         throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
-      for (const v of values) {
-        if (map2.has(v)) {
-          throw new Error(`Duplicate discriminator value "${String(v)}"`);
+      for (const v2 of values) {
+        if (map2.has(v2)) {
+          throw new Error(`Duplicate discriminator value "${String(v2)}"`);
         }
-        map2.set(v, o);
+        map2.set(v2, o);
       }
     }
     return map2;
@@ -4770,8 +4776,8 @@ var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
 var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "values", () => {
-    const v = def.innerType._zod.values;
-    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
+    const v2 = def.innerType._zod.values;
+    return v2 ? new Set([...v2].filter((x) => x !== void 0)) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
     const result = def.innerType._zod.run(payload, ctx);
@@ -7168,7 +7174,7 @@ var error17 = () => {
         if (issue2.values.length === 1) {
           return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive(issue2.values[0])}`;
         }
-        const stringified = issue2.values.map((v) => stringifyPrimitive(v));
+        const stringified = issue2.values.map((v2) => stringifyPrimitive(v2));
         if (issue2.values.length === 2) {
           return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
         }
@@ -11923,7 +11929,7 @@ function _set(Class2, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new Class2({
     type: "enum",
     entries,
@@ -12128,8 +12134,8 @@ function _stringbool(Classes, _params) {
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
   let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
   if (params.case !== "sensitive") {
-    truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
-    falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
+    truthyArray = truthyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
+    falsyArray = falsyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
   }
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
@@ -12671,9 +12677,9 @@ var dateProcessor = (_schema, ctx, _json, _params) => {
 var enumProcessor = (schema, _ctx, json2, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
-  if (values.every((v) => typeof v === "number"))
+  if (values.every((v2) => typeof v2 === "number"))
     json2.type = "number";
-  if (values.every((v) => typeof v === "string"))
+  if (values.every((v2) => typeof v2 === "string"))
     json2.type = "string";
   json2.enum = values;
 };
@@ -12706,13 +12712,13 @@ var literalProcessor = (schema, ctx, json2, _params) => {
       json2.const = val;
     }
   } else {
-    if (vals.every((v) => typeof v === "number"))
+    if (vals.every((v2) => typeof v2 === "number"))
       json2.type = "number";
-    if (vals.every((v) => typeof v === "string"))
+    if (vals.every((v2) => typeof v2 === "string"))
       json2.type = "string";
-    if (vals.every((v) => typeof v === "boolean"))
+    if (vals.every((v2) => typeof v2 === "boolean"))
       json2.type = "boolean";
-    if (vals.every((v) => v === null))
+    if (vals.every((v2) => v2 === null))
       json2.type = "null";
     json2.enum = vals;
   }
@@ -12810,11 +12816,11 @@ var objectProcessor = (schema, ctx, _json, params) => {
   }
   const allKeys = new Set(Object.keys(shape));
   const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v = def.shape[key]._zod;
+    const v2 = def.shape[key]._zod;
     if (ctx.io === "input") {
-      return v.optin === void 0;
+      return v2.optin === void 0;
     } else {
-      return v.optout === void 0;
+      return v2.optout === void 0;
     }
   }));
   if (requiredKeys.size > 0) {
@@ -12934,7 +12940,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   }
   const keyValues = keyType._zod.values;
   if (keyValues) {
-    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+    const validKeyValues = [...keyValues].filter((v2) => typeof v2 === "string" || typeof v2 === "number");
     if (validKeyValues.length > 0) {
       json2.required = validKeyValues;
     }
@@ -13499,12 +13505,12 @@ function _installLazyMethods(inst, group, methods) {
         });
         return bound;
       },
-      set(v) {
+      set(v2) {
         Object.defineProperty(this, key, {
           configurable: true,
           writable: true,
           enumerable: true,
-          value: v
+          value: v2
         });
       }
     });
@@ -14392,7 +14398,7 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new ZodEnum({
     type: "enum",
     entries,
@@ -14946,10 +14952,10 @@ function convertBaseSchema(schema, ctx) {
     if (enumValues.length === 1) {
       return z.literal(enumValues[0]);
     }
-    if (enumValues.every((v) => typeof v === "string")) {
+    if (enumValues.every((v2) => typeof v2 === "string")) {
       return z.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z.literal(v));
+    const literalSchemas = enumValues.map((v2) => z.literal(v2));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
@@ -15296,7 +15302,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-HSJYPBJU.js
+// ../../ir-core/dist/chunk-52CH76PE.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -15360,14 +15366,24 @@ var functionCallSemantics = defineBoundarySemantics({
      */
     canPair: () => true,
     /**
-     * `"fn:<package>::<exportPath>"` when both are set. Other in-process
-     * function-call units, such as components and bare handlers inside
-     * one repo, have no key at all.
+     * `"fn:<package>::<exportPath>"` when both are set, and
+     * `"fn:<module>::<exportName>"` for an in-repo unit that states its
+     * module, the way a server action does. Components and bare
+     * handlers state neither and have no key at all.
      */
+    rewritePaths(semantics, rewrite) {
+      if (semantics.module === void 0) {
+        return semantics;
+      }
+      return { ...semantics, module: rewrite(semantics.module) };
+    },
     identityKey(semantics) {
       if (semantics.package !== void 0 && semantics.exportPath !== void 0 && semantics.exportPath.length > 0) {
         return fnIdentityKey(semantics.package, semantics.exportPath);
       }
+      if (semantics.module !== void 0 && semantics.exportName !== void 0) {
+        return fnIdentityKey(semantics.module, [semantics.exportName]);
+      }
       return null;
     }
   }
@@ -15878,7 +15894,16 @@ var ConfidenceInfoSchema = external_exports.object({
 });
 var SourceLocationSchema = external_exports.object({
   file: external_exports.string(),
+  /** Line numbers, for a person reading the summary or an editor link. */
   range: external_exports.object({ start: external_exports.number(), end: external_exports.number() }),
+  /**
+   * Character offsets of the unit in its file. Identity and joins
+   * measure with these, since two functions can share a line and never
+   * an offset range; the line `range` above is the presentation of the
+   * same place. Absent on summaries no source position backs, a
+   * contract artifact's say.
+   */
+  span: external_exports.object({ start: external_exports.number(), end: external_exports.number() }).optional(),
   exportName: external_exports.string().nullable(),
   /**
    * The project the extract was pointed at, by the name that project
@@ -16003,6 +16028,733 @@ function storageBinding(opts) {
   };
 }
 
+// ../../resolution/dist/index.js
+var import_datalog = require("@suss/datalog");
+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.
+  // 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_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_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_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_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("value"), VALUE_STEP],
+    [
+      (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_datalog2.rule)(
+    "stepsTo",
+    [(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_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("held"), VALUE_STEP],
+    [
+      (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_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("cls"), VALUE_STEP],
+    [
+      (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_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("a"), VALUE_STEP],
+    [
+      (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_datalog2.rule)(
+    "stepsTo",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("a"), VALUE_STEP],
+    [
+      (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_datalog2.rule)(
+    "stepsTo",
+    [(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_datalog2.rule)(
+    "reaches",
+    [(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_datalog2.rule)(
+    "reaches",
+    [(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)("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_datalog2.rule)(
+    "reaches",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.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"), VALUE_STEP)
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "reaches",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.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_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_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_datalog2.rule)(
+    "comesTo",
+    [(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_datalog2.rule)(
+    "givesBack",
+    [(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_datalog2.rule)(
+    "givesBack",
+    [(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_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_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_datalog2.rule)(
+    "isWrittenAs",
+    [(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_datalog2.rule)(
+    "paramAt",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.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_datalog2.rule)(
+    "passesArgument",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.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_datalog2.rule)(
+    "passesArgument",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("p"), (0, import_datalog2.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"))
+    ]
+  ),
+  // 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",
+    [(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_datalog2.rule)(
+    "moduleExport",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.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_datalog2.rule)(
+    "moduleExport",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.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_datalog2.rule)(
+    "invokes",
+    [(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_datalog2.rule)(
+    "invokes",
+    [(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_datalog2.rule)(
+    "objectOf",
+    [(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_datalog2.rule)(
+    "objectOf",
+    [(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_datalog2.rule)(
+    "callsFunction",
+    [(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_datalog2.rule)(
+    "callsFunction",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
+    [
+      (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_datalog2.rule)(
+    "callsFunction",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")],
+    [
+      (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
+  // declares is found on a subclass that never overrode it. A method both
+  // 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_datalog2.rule)(
+    "contains",
+    [(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_datalog2.rule)(
+    "contains",
+    [(0, import_datalog2.variable)("cls"), (0, import_datalog2.variable)("n"), (0, import_datalog2.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_datalog2.rule)(
+    "returnsFunc",
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.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_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_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_datalog2.rule)(
+    "unwraps",
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")],
+    [
+      (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
+  // (an identifier bound to the parameter), or through a call to
+  // 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_datalog2.rule)(
+    "flowsToParam",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.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_datalog2.rule)(
+    "flowsToParam",
+    [(0, import_datalog2.variable)("r"), (0, import_datalog2.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_datalog2.rule)(
+    "unwraps",
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("k")],
+    [
+      (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_datalog2.rule)(
+    "comesFrom",
+    [(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_datalog2.rule)(
+    "comesFrom",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.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 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")],
+    [
+      (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_datalog2.rule)(
+    "callsInto",
+    [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("m"), (0, import_datalog2.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_datalog2.rule)(
+    "resolves",
+    [(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_datalog2.rule)(
+    "wantedResolves",
+    [(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_datalog2.rule)(
+    "wantedComesTo",
+    [(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_datalog2.rule)(
+    "wantedComesTo",
+    [(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_datalog2.rule)(
+    "wantedIsWrittenAs",
+    [(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_datalog2.rule)(
+    "wantedObjectOf",
+    [(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_datalog2.rule)(
+    "wantedParamAt",
+    [(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_datalog2.rule)(
+    "wantedComesFrom",
+    [(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")],
+    [
+      (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"))
+    ]
+  ),
+  // 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 = [
+  ...new Set(RESOLUTION_QUESTIONS.map((r) => r.head.relation))
+];
+
 // src/storage.ts
 function children2(node) {
   return node.namedChildren.filter((child) => child !== null);
@@ -16023,21 +16775,17 @@ function rootConstant(node) {
   }
   return rootConstant(receiver);
 }
-function reachesBase(facts, classKey, bases, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(classKey)) {
-    return false;
-  }
-  seen.add(classKey);
-  const named = facts.facts("extendsNamed").filter((row) => String(row[0]) === classKey).map((row) => String(row[1]));
-  if (named.some((name) => bases.includes(name))) {
-    return true;
-  }
-  return facts.facts("extends").filter((row) => String(row[0]) === classKey).flatMap(
-    (row) => facts.facts("binds").filter((bound) => String(bound[0]) === String(row[1])).map((bound) => String(bound[1]))
-  ).some((next) => reachesBase(facts, next, bases, seen));
+var ANCESTRY_PROGRAM = (0, import_datalog3.deriveOnDemand)(
+  [...RESOLUTION_RULES, ...RESOLUTION_QUESTIONS],
+  ANSWER_RELATIONS
+);
+function reachesBase(facts, classKey, bases) {
+  facts.add("wantedAncestry", [classKey]);
+  (0, import_datalog3.evaluate)(facts, ANCESTRY_PROGRAM.rules);
+  return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
 }
-function classBehind(facts, constant) {
-  const wanted = `#${constant.text}`;
+function classBehind(facts, constant2) {
+  const wanted = `#${constant2.text}`;
   const bound = new Set(
     facts.facts("binds").filter((row) => String(row[0]).endsWith(wanted)).map((row) => String(row[1]))
   );
@@ -16080,11 +16828,11 @@ function storageEffects(calls, options) {
     if (partOfOne.has(call.id)) {
       continue;
     }
-    const constant = rootConstant(call);
-    if (constant === null) {
+    const constant2 = rootConstant(call);
+    if (constant2 === null) {
       continue;
     }
-    const classKey = classBehind(options.facts, constant);
+    const classKey = classBehind(options.facts, constant2);
     if (classKey === void 0) {
       continue;
     }
@@ -16102,7 +16850,7 @@ function storageEffects(calls, options) {
         recognition: "ruby-storage",
         storageSystem: pattern.storageSystem,
         scope: pattern.baseClasses[0] ?? "",
-        container: constant.text
+        container: constant2.text
       }),
       callee: call.text,
       interaction: {
@@ -16589,6 +17337,7 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
       kind: "resolver",
       file: filePath,
       range: rangeOf(decl.node),
+      span: spanOf(decl.node),
       exportName: null,
       exportPath: null
     },
@@ -16658,7 +17407,7 @@ async function parseRuby(source) {
 // src/project.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
-var import_datalog = require("@suss/datalog");
+var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
 
 // src/facts/values.ts
@@ -17101,7 +17850,7 @@ function emitConstantBindings(db, perFile) {
 
 // src/project.ts
 async function extractRubyProject(options) {
-  const db = new import_datalog.Database();
+  const db = new import_datalog4.Database();
   const summaries = [];
   const constants = [];
   const cache = createFileCache(