@suss/adapter-python 0.19.0 → 0.20.0

package/dist/index.cjs

@@ -69,6 +69,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);
 }
@@ -1923,8 +1926,8 @@ function assertNever(_x) {
 function assert(_) {
 }
 function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v2]) => v2);
+  const numericValues = Object.values(entries).filter((v3) => typeof v3 === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v3]) => v3);
   return values;
 }
 function joinValues(array2, separator = "|") {
@@ -1978,9 +1981,9 @@ function defineLazy(object2, key, getter) {
       }
       return value;
     },
-    set(v2) {
+    set(v3) {
       Object.defineProperty(object2, key, {
-        value: v2
+        value: v3
         // configurable: true,
       });
     },
@@ -3667,10 +3670,10 @@ var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
       v7: 7,
       v8: 8
     };
-    const v2 = versionMap[def.version];
-    if (v2 === void 0)
+    const v3 = versionMap[def.version];
+    if (v3 === void 0)
       throw new Error(`Invalid UUID version: "${def.version}"`);
-    def.pattern ?? (def.pattern = uuid(v2));
+    def.pattern ?? (def.pattern = uuid(v3));
   } else
     def.pattern ?? (def.pattern = uuid());
   $ZodStringFormat.init(inst, def);
@@ -4275,8 +4278,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 v2 of field2.values)
-          propValues[key].add(v2);
+        for (const v3 of field2.values)
+          propValues[key].add(v3);
       }
     }
     return propValues;
@@ -4571,10 +4574,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, v2] of Object.entries(pv)) {
+      for (const [k, v3] of Object.entries(pv)) {
         if (!propValues[k])
           propValues[k] = /* @__PURE__ */ new Set();
-        for (const val of v2) {
+        for (const val of v3) {
           propValues[k].add(val);
         }
       }
@@ -4588,11 +4591,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 v2 of values) {
-        if (map2.has(v2)) {
-          throw new Error(`Duplicate discriminator value "${String(v2)}"`);
+      for (const v3 of values) {
+        if (map2.has(v3)) {
+          throw new Error(`Duplicate discriminator value "${String(v3)}"`);
         }
-        map2.set(v2, o);
+        map2.set(v3, o);
       }
     }
     return map2;
@@ -5231,8 +5234,8 @@ var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
 var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "values", () => {
-    const v2 = def.innerType._zod.values;
-    return v2 ? new Set([...v2].filter((x) => x !== void 0)) : void 0;
+    const v3 = def.innerType._zod.values;
+    return v3 ? new Set([...v3].filter((x) => x !== void 0)) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
     const result = def.innerType._zod.run(payload, ctx);
@@ -7629,7 +7632,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((v2) => stringifyPrimitive(v2));
+        const stringified = issue2.values.map((v3) => stringifyPrimitive(v3));
         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]}`;
         }
@@ -12384,7 +12387,7 @@ function _set(Class2, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v3) => [v3, v3])) : values;
   return new Class2({
     type: "enum",
     entries,
@@ -12589,8 +12592,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((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
-    falsyArray = falsyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
+    truthyArray = truthyArray.map((v3) => typeof v3 === "string" ? v3.toLowerCase() : v3);
+    falsyArray = falsyArray.map((v3) => typeof v3 === "string" ? v3.toLowerCase() : v3);
   }
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
@@ -13132,9 +13135,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((v2) => typeof v2 === "number"))
+  if (values.every((v3) => typeof v3 === "number"))
     json2.type = "number";
-  if (values.every((v2) => typeof v2 === "string"))
+  if (values.every((v3) => typeof v3 === "string"))
     json2.type = "string";
   json2.enum = values;
 };
@@ -13167,13 +13170,13 @@ var literalProcessor = (schema, ctx, json2, _params) => {
       json2.const = val;
     }
   } else {
-    if (vals.every((v2) => typeof v2 === "number"))
+    if (vals.every((v3) => typeof v3 === "number"))
       json2.type = "number";
-    if (vals.every((v2) => typeof v2 === "string"))
+    if (vals.every((v3) => typeof v3 === "string"))
       json2.type = "string";
-    if (vals.every((v2) => typeof v2 === "boolean"))
+    if (vals.every((v3) => typeof v3 === "boolean"))
       json2.type = "boolean";
-    if (vals.every((v2) => v2 === null))
+    if (vals.every((v3) => v3 === null))
       json2.type = "null";
     json2.enum = vals;
   }
@@ -13271,11 +13274,11 @@ var objectProcessor = (schema, ctx, _json, params) => {
   }
   const allKeys = new Set(Object.keys(shape));
   const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v2 = def.shape[key]._zod;
+    const v3 = def.shape[key]._zod;
     if (ctx.io === "input") {
-      return v2.optin === void 0;
+      return v3.optin === void 0;
     } else {
-      return v2.optout === void 0;
+      return v3.optout === void 0;
     }
   }));
   if (requiredKeys.size > 0) {
@@ -13395,7 +13398,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   }
   const keyValues = keyType._zod.values;
   if (keyValues) {
-    const validKeyValues = [...keyValues].filter((v2) => typeof v2 === "string" || typeof v2 === "number");
+    const validKeyValues = [...keyValues].filter((v3) => typeof v3 === "string" || typeof v3 === "number");
     if (validKeyValues.length > 0) {
       json2.required = validKeyValues;
     }
@@ -13960,12 +13963,12 @@ function _installLazyMethods(inst, group, methods) {
         });
         return bound;
       },
-      set(v2) {
+      set(v3) {
         Object.defineProperty(this, key, {
           configurable: true,
           writable: true,
           enumerable: true,
-          value: v2
+          value: v3
         });
       }
     });
@@ -14853,7 +14856,7 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v3) => [v3, v3])) : values;
   return new ZodEnum({
     type: "enum",
     entries,
@@ -15407,10 +15410,10 @@ function convertBaseSchema(schema, ctx) {
     if (enumValues.length === 1) {
       return z.literal(enumValues[0]);
     }
-    if (enumValues.every((v2) => typeof v2 === "string")) {
+    if (enumValues.every((v3) => typeof v3 === "string")) {
       return z.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v2) => z.literal(v2));
+    const literalSchemas = enumValues.map((v3) => z.literal(v3));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
@@ -15757,7 +15760,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}`;
 }
@@ -15821,14 +15824,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;
     }
   }
@@ -16339,7 +16352,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
@@ -16547,7 +16569,48 @@ var import_datalog3 = require("@suss/datalog");
 // ../../resolution/dist/index.js
 var import_datalog = require("@suss/datalog");
 var import_datalog2 = require("@suss/datalog");
+function joinMountedPath(prefix, path4) {
+  const trimmed = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  return trimmed === "" ? path4 : trimmed + path4;
+}
+function mountPathsOf(edges, childId) {
+  return pathsOf(edges, /* @__PURE__ */ new Map(), childId, /* @__PURE__ */ new Set());
+}
+function pathsOf(edges, memo, childId, visiting) {
+  const cached2 = memo.get(childId);
+  if (cached2 !== void 0) {
+    return cached2;
+  }
+  if (visiting.has(childId)) {
+    memo.set(childId, null);
+    return null;
+  }
+  const own = edges.get(childId);
+  if (own === void 0 || own.length === 0) {
+    memo.set(childId, [""]);
+    return [""];
+  }
+  visiting.add(childId);
+  const composed = /* @__PURE__ */ new Set();
+  let unstated = false;
+  for (const edge of own) {
+    const parentPaths = pathsOf(edges, memo, edge.parentId, visiting);
+    if (parentPaths === null) {
+      unstated = true;
+      break;
+    }
+    for (const parentPath of parentPaths) {
+      composed.add(joinMountedPath(parentPath, edge.prefix));
+    }
+  }
+  visiting.delete(childId);
+  const result = unstated ? null : [...composed];
+  memo.set(childId, result);
+  return result;
+}
 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.
@@ -16767,6 +16830,21 @@ var RESOLUTION_RULES = [
       (0, import_datalog2.lit)("callKeywordArg", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("a"))
     ]
   ),
+  // Which module's export a re-exported name forwards to, however
+  // many barrels deep the forwarding runs.
+  (0, import_datalog2.rule)(
+    "moduleForwards",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")],
+    [(0, import_datalog2.lit)("reExports", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"))]
+  ),
+  (0, import_datalog2.rule)(
+    "moduleForwards",
+    [(0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m3"), (0, import_datalog2.variable)("n3")],
+    [
+      (0, import_datalog2.lit)("reExports", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")),
+      (0, import_datalog2.lit)("moduleForwards", (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"), (0, import_datalog2.variable)("m3"), (0, import_datalog2.variable)("n3"))
+    ]
+  ),
   // What a module exports: directly, or through re-export chains.
   (0, import_datalog2.rule)(
     "moduleExport",
@@ -16946,15 +17024,9 @@ var RESOLUTION_RULES = [
       (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   ),
-  // Calling f ends up calling the name n that module m exports. One hop
-  // is f's own body, including the closures it declares; the other hop
-  // is a function f's body calls, so a wrapper of a wrapper answers
-  // with what the innermost one reaches.
-  //
-  // Several answers for one function is the normal case, not an
-  // ambiguity: a project decorator that composes two library decorators
-  // applies both. A caller asks whether a particular (m, n) is among
-  // them.
+  // Calling f ends up calling the name n that module m exports, one
+  // hop through f's own body or deeper through a wrapper of a wrapper.
+  // Several results is normal: a composed decorator applies them all.
   (0, import_datalog2.rule)(
     "callsInto",
     [(0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
@@ -17022,6 +17094,155 @@ var RESOLUTION_QUESTIONS = [
     [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
     [(0, import_datalog2.lit)("wantedOrigin", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("comesFrom", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))]
   ),
+  // Call-origin questions, for attribution, in their own demand
+  // class. Attribution stops at the import declaration, so nothing
+  // here demands reaches or callsInto. The chains are closures with
+  // no depth bound: an alias run of any length resolves.
+  (0, import_datalog2.rule)("callOriginChain", [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("x")], [(0, import_datalog2.lit)("wantedCallOrigin", (0, import_datalog2.variable)("x"))]),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  // The chain with at least one hop taken, which is what tells a
+  // destructured binding apart from asking about a node directly.
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callOriginChainStepped",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("fallbackBranch", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
+  // An import of a project barrel is an import of what the barrel
+  // forwards, so the pair surfaces the module behind the chain.
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2")],
+    [
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")),
+      (0, import_datalog2.lit)("moduleForwards", (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("m2"), (0, import_datalog2.variable)("n2"))
+    ]
+  ),
+  // A namespace member: the module's export of the member's own name.
+  // The imports literal leads, since it is the smallest relation.
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("d"), (0, import_datalog2.variable)("m"), NAMESPACE_IMPORT),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("d")),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("o"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"))
+    ]
+  ),
+  // What a call made: through the call to its callee, whose own alias
+  // chain leads to the import.
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("f")],
+    [(0, import_datalog2.lit)("callOriginChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("c")), (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "callMadeChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z")],
+    [(0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")), (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginPair",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("callMadeChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
+  // A member destructured off what a call made keeps the member name
+  // as one more path segment.
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callOriginChainStepped", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("e")),
+      (0, import_datalog2.lit)("readsProperty", (0, import_datalog2.variable)("e"), (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("call", (0, import_datalog2.variable)("c"), (0, import_datalog2.variable)("f"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("binds", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "callMemberChain",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("endsHolding", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"))
+    ]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedCallOriginMember",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"), (0, import_datalog2.variable)("p")],
+    [
+      (0, import_datalog2.lit)("callMemberChain", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("p")),
+      (0, import_datalog2.lit)("imports", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
+    ]
+  ),
   (0, import_datalog2.rule)(
     "wantedCallsInto",
     [(0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
@@ -17030,6 +17251,81 @@ var RESOLUTION_QUESTIONS = [
       (0, import_datalog2.lit)("comesTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("g")),
       (0, import_datalog2.lit)("callsInto", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
+  ),
+  // 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 = [
@@ -17796,7 +18092,7 @@ function classRouteUnits(pattern, pack, classification, classNode, module2, opti
   if (className === void 0 || bodyNode === null || classScope === void 0) {
     return [];
   }
-  const routePath = readRoutePath(
+  const entries = readRoutePaths(
     pattern,
     pathArgument,
     classification,
@@ -17814,32 +18110,35 @@ function classRouteUnits(pattern, pack, classification, classNode, module2, opti
     if (verb === void 0 || methodName2 === void 0) {
       continue;
     }
-    units.push(
-      ...routeUnitOrAbstention(
-        {
-          pack,
-          name: `${className}.${methodName2}`,
-          exportPath: [className, methodName2],
-          method: verb,
-          routePath,
-          requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
-          readsReturnedStatus: pattern.statusFromReturnedTuple === true,
-          injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
-          definitionNode: maybeMethod,
-          enclosingScope: classScope,
-          module: module2,
-          filePath: options.filePath,
-          skipReceiverParam: true,
-          responseShape: import_extractor3.absentReading,
-          statusCode: defaultedStatus(
-            readReturnedStatus(pattern, maybeMethod),
-            pattern
-          ),
-          storage: options.storage
-        },
-        options
-      )
-    );
+    for (const entry of entries) {
+      units.push(
+        ...routeUnitOrAbstention(
+          {
+            pack,
+            name: `${className}.${methodName2}`,
+            exportPath: [className, methodName2],
+            method: verb,
+            routePath: entry.routePath,
+            ...entry.mount !== void 0 ? { mount: entry.mount } : {},
+            requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
+            readsReturnedStatus: pattern.statusFromReturnedTuple === true,
+            injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
+            definitionNode: maybeMethod,
+            enclosingScope: classScope,
+            module: module2,
+            filePath: options.filePath,
+            skipReceiverParam: true,
+            responseShape: import_extractor3.absentReading,
+            statusCode: defaultedStatus(
+              readReturnedStatus(pattern, maybeMethod),
+              pattern
+            ),
+            storage: options.storage
+          },
+          options
+        )
+      );
+    }
   }
   return units;
 }
@@ -17853,6 +18152,47 @@ function readRoutePath(pattern, pathArgument, classification, module2, options)
     (path4, range) => readPathTemplate(pattern, path4, range)
   );
 }
+function readRoutePaths(pattern, pathArgument, classification, module2, options) {
+  const resolution = routerResolutionOf(
+    pattern,
+    classification,
+    module2,
+    options
+  );
+  if (resolution?.kind !== "composedMany") {
+    return [
+      {
+        routePath: readRoutePath(
+          pattern,
+          pathArgument,
+          classification,
+          module2,
+          options
+        )
+      }
+    ];
+  }
+  return resolution.values.map((prefix) => ({
+    routePath: (0, import_extractor3.andThenReading)(
+      (0, import_extractor3.andThenReading)(
+        pathArgument,
+        (literal2, range) => (0, import_extractor3.writtenReading)(servedSpelling(pattern, prefix + literal2), range)
+      ),
+      (path4, range) => readPathTemplate(pattern, path4, range)
+    ),
+    mount: { siblings: resolution.values.length, prefix }
+  }));
+}
+function routerResolutionOf(pattern, classification, module2, options) {
+  if (pattern.routerComposition === void 0 || options.routerIndex === void 0 || classification.objectName === null) {
+    return null;
+  }
+  return options.routerIndex.resolve(
+    pattern,
+    classification.objectModule ?? module2,
+    classification.objectName
+  );
+}
 function composeRoutePath(pattern, classification, module2, options, literal2, range) {
   const prefix = readRouterPrefix(
     pattern,
@@ -18106,39 +18446,42 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
     return [];
   }
   const ctx = createAnnotationContext(module2.scopeFor);
-  return routeUnitOrAbstention(
-    {
-      pack,
-      name: functionName,
-      exportPath: [functionName],
-      method: verb,
-      routePath: readRoutePath(
-        pattern,
-        readPathArgument(classification),
-        classification,
-        module2,
-        options
-      ),
-      requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
-      readsReturnedStatus: pattern.statusFromReturnedTuple === true,
-      injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
-      definitionNode: functionNode,
-      enclosingScope: module2.moduleScope,
-      module: module2,
-      filePath: options.filePath,
-      skipReceiverParam: false,
-      responseShape: readResponseModel(pattern, classification, module2, ctx),
-      statusCode: defaultedStatus(
-        declaredOrReturnedStatus(
-          readStatusCode(pattern, classification),
-          readReturnedStatus(pattern, functionNode)
-        ),
-        pattern
-      ),
-      definitionsCtx: ctx,
-      storage: options.storage
-    },
+  return readRoutePaths(
+    pattern,
+    readPathArgument(classification),
+    classification,
+    module2,
     options
+  ).flatMap(
+    (entry) => routeUnitOrAbstention(
+      {
+        pack,
+        name: functionName,
+        exportPath: [functionName],
+        method: verb,
+        routePath: entry.routePath,
+        ...entry.mount !== void 0 ? { mount: entry.mount } : {},
+        requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
+        readsReturnedStatus: pattern.statusFromReturnedTuple === true,
+        injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
+        definitionNode: functionNode,
+        enclosingScope: module2.moduleScope,
+        module: module2,
+        filePath: options.filePath,
+        skipReceiverParam: false,
+        responseShape: readResponseModel(pattern, classification, module2, ctx),
+        statusCode: defaultedStatus(
+          declaredOrReturnedStatus(
+            readStatusCode(pattern, classification),
+            readReturnedStatus(pattern, functionNode)
+          ),
+          pattern
+        ),
+        definitionsCtx: ctx,
+        storage: options.storage
+      },
+      options
+    )
   );
 }
 function readResponseShape(declared, readAnnotation) {
@@ -18281,6 +18624,7 @@ function buildRouteUnit(options) {
       kind: "handler",
       file: filePath,
       range: rangeOf(definitionNode),
+      span: spanOf(definitionNode),
       exportName: exportPath[0] ?? name,
       exportPath
     },
@@ -18300,7 +18644,8 @@ function buildRouteUnit(options) {
       ...unreadRoleReadings(parameters, rangeOf(definitionNode)),
       ...responseShape.passedOver
     ],
-    ...collectedDefinitions(ctx) !== null ? { definitions: collectedDefinitions(ctx) } : {}
+    ...collectedDefinitions(ctx) !== null ? { definitions: collectedDefinitions(ctx) } : {},
+    ...options.mount !== void 0 ? { mount: options.mount } : {}
   };
 }
 function unreadRoleReadings(parameters, range) {
@@ -18693,24 +19038,90 @@ function buildRouterIndex(files, packs, resolverOptions) {
         return ownPrefix;
       }
       const routerPath = displayPaths.get(module2);
-      const mount = index.mounts.get(construction);
-      if (mount === void 0) {
+      const states = index.mounts.get(construction);
+      if (states === void 0 || states.length === 0) {
         return { kind: "abstain", reason: unmountedReason(index, routerPath) };
       }
-      if (mount.kind === "abstain") {
-        return { kind: "abstain", reason: mount.reason };
+      for (const state of states) {
+        if (state.kind === "abstain") {
+          return { kind: "abstain", reason: state.reason };
+        }
+        const rivalled = rivalRegistration(index, state.site, routerPath);
+        if (rivalled !== null) {
+          return { kind: "abstain", reason: rivalled };
+        }
+      }
+      const composed = composedMountPrefix(index, construction);
+      if (composed.kind === "abstain") {
+        return composed;
       }
-      const rivalled = rivalRegistration(index, mount.site, routerPath);
-      if (rivalled !== null) {
-        return { kind: "abstain", reason: rivalled };
+      if (composed.kind === "composedMany") {
+        return {
+          kind: "composedMany",
+          values: composed.values.map((value) => value + ownPrefix.value)
+        };
       }
       return {
         kind: "composed",
-        value: mount.includePrefix + ownPrefix.value
+        value: composed.value + ownPrefix.value
       };
     }
   };
 }
+function composedMountPrefix(index, construction) {
+  const paths = mountPathsOf(mountEdgesOf(index), construction.valueKey);
+  if (paths === null) {
+    return {
+      kind: "abstain",
+      reason: "is mounted through a chain of routers this reading cannot compose"
+    };
+  }
+  const distinct = [...new Set(paths)];
+  const only = distinct[0];
+  if (only === void 0) {
+    return {
+      kind: "abstain",
+      reason: "is mounted through a chain of routers this reading cannot compose"
+    };
+  }
+  if (distinct.length > 1) {
+    return { kind: "composedMany", values: distinct };
+  }
+  return { kind: "composed", value: only };
+}
+function mountEdgesOf(index) {
+  if (index.mountEdges !== void 0) {
+    return index.mountEdges;
+  }
+  const edges = /* @__PURE__ */ new Map();
+  const push = (childKey, edge) => {
+    const list = edges.get(childKey) ?? [];
+    list.push(edge);
+    edges.set(childKey, list);
+  };
+  for (const [target, states] of index.mounts) {
+    for (const state of states) {
+      if (state.kind === "abstain") {
+        push(target.valueKey, { parentId: target.valueKey, prefix: "" });
+        continue;
+      }
+      push(target.valueKey, {
+        parentId: state.parentValueKey ?? rootKeyOf(target),
+        prefix: state.includePrefix
+      });
+    }
+  }
+  for (const [valueKey2, construction] of index.byValueKey) {
+    if (!index.mounts.has(construction)) {
+      push(valueKey2, { parentId: valueKey2, prefix: "" });
+    }
+  }
+  index.mountEdges = edges;
+  return edges;
+}
+function rootKeyOf(target) {
+  return `root:${target.valueKey}`;
+}
 function declaredOnMountObject(index, module2, objectName) {
   const objectPrefix = index.objectPrefixes.get(module2)?.get(objectName);
   if (objectPrefix === void 0) {
@@ -19051,7 +19462,8 @@ var MOUNT_STATE_BY_EFFECT = {
   prefixes: (statedPrefix, site) => ({
     kind: "mounted",
     includePrefix: statedPrefix,
-    site
+    site,
+    parentValueKey: null
   }),
   replaces: () => ({
     kind: "abstain",
@@ -19059,14 +19471,9 @@ var MOUNT_STATE_BY_EFFECT = {
   })
 };
 function recordMount(index, target, state) {
-  if (index.mounts.has(target)) {
-    index.mounts.set(target, {
-      kind: "abstain",
-      reason: "is mounted more than once"
-    });
-    return;
-  }
-  index.mounts.set(target, state);
+  const states = index.mounts.get(target) ?? [];
+  states.push(state);
+  index.mounts.set(target, states);
 }
 function collectMounts(bound, byFile, importModule, composition, resolverOptions, index) {
   const scan = {
@@ -19095,7 +19502,7 @@ var WALK_DESCENTS = {
   decorated_definition: (stmt, position, scan, visit) => {
     walkStatements([stripDecorators(stmt).definition], position, scan, visit);
   },
-  function_definition: (stmt, position, scan, visit) => {
+  function_definition: (stmt, _position, scan, visit) => {
     const scope = scan.bound.module.scopeFor.get(stmt.id);
     if (scope === void 0) {
       return;
@@ -19326,8 +19733,10 @@ function recordMountStatement(stmt, position, scan) {
     position.scope,
     scan
   );
+  const includerKey = nodeId(scan.bound.file, mountCall.includerCall);
   const state = mountStateOf(
     mountCall.includerConstructorName,
+    scan.index.byValueKey.get(includerKey) ?? null,
     keywordArgs,
     objectPrefix,
     scan.composition,
@@ -19339,18 +19748,15 @@ function recordMountStatement(stmt, position, scan) {
     recordMount(scan.index, target, state);
   }
 }
-function mountStateOf(includerConstructorName, keywordArgs, objectPrefix, composition, site, scope) {
-  if (includerConstructorName === composition.routerConstructorName) {
-    return {
-      kind: "abstain",
-      reason: "is mounted onto another router, one hop past what this reading follows"
-    };
-  }
-  if (objectPrefix.kind === "abstain") {
-    return {
-      kind: "abstain",
-      reason: `is mounted on an object that ${objectPrefix.reason}`
-    };
+function mountStateOf(includerConstructorName, includer, keywordArgs, objectPrefix, composition, site, scope) {
+  const base = mountBaseOf(
+    includerConstructorName,
+    includer,
+    objectPrefix,
+    composition
+  );
+  if (base.kind === "abstain") {
+    return base;
   }
   const mountPrefix = readPrefixKeyword(
     keywordArgs,
@@ -19365,14 +19771,56 @@ function mountStateOf(includerConstructorName, keywordArgs, objectPrefix, compos
     };
   }
   if (mountPrefix.kind === "unstated") {
-    return { kind: "mounted", includePrefix: objectPrefix.value, site };
+    return {
+      kind: "mounted",
+      includePrefix: base.value,
+      site,
+      parentValueKey: base.parentValueKey
+    };
   }
   const effect = composition.mountPrefixEffect ?? "prefixes";
   const state = MOUNT_STATE_BY_EFFECT[effect](mountPrefix.value, site);
   if (state.kind === "abstain") {
     return state;
   }
-  return { ...state, includePrefix: objectPrefix.value + state.includePrefix };
+  return {
+    ...state,
+    includePrefix: base.value + state.includePrefix,
+    parentValueKey: base.parentValueKey
+  };
+}
+function mountBaseOf(includerConstructorName, includer, objectPrefix, composition) {
+  if (includerConstructorName !== composition.routerConstructorName) {
+    if (objectPrefix.kind === "abstain") {
+      return {
+        kind: "abstain",
+        reason: `is mounted on an object that ${objectPrefix.reason}`
+      };
+    }
+    return {
+      kind: "composed",
+      value: objectPrefix.value,
+      parentValueKey: null
+    };
+  }
+  if (includer === null) {
+    return {
+      kind: "abstain",
+      reason: "is mounted onto a router this reading never saw constructed"
+    };
+  }
+  const parentOwn = composedOwnPrefix(includer.prefix, composition);
+  if (parentOwn.kind === "abstain") {
+    return {
+      kind: "abstain",
+      reason: `is mounted onto a router that ${parentOwn.reason}`
+    };
+  }
+  return {
+    kind: "composed",
+    value: parentOwn.value,
+    parentValueKey: includer.valueKey
+  };
 }
 function collectCarrierCalls(carrier, scan) {
   walkStatements(
@@ -19650,7 +20098,11 @@ async function extractPythonProject(options) {
     ...couldMatch,
     ...storagePatterns.flatMap((pattern) => pattern.queryFunctions ?? [])
   ]);
-  const leadsToStorage = functionsReachingStorage(definitions, startsAQuery);
+  const leadsToStorage = functionsReachingStorage(
+    db,
+    definitions,
+    startsAQuery
+  );
   const routerIndex = buildRouterIndex(bound, options.packs, {
     roots: options.roots,
     ...mountsRouters ? { facts: db } : {}
@@ -19779,32 +20231,33 @@ function callsUnder(node, found = []) {
   }
   return found;
 }
-function functionsReachingStorage(definitions, couldMatch) {
-  const bodies = [];
+var REACHES_STORAGE_RULES = [
+  (0, import_datalog4.rule)(
+    "reachesStorage",
+    [(0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("defCallsName", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("m")), (0, import_datalog4.lit)("queryStart", (0, import_datalog4.variable)("m"))]
+  ),
+  (0, import_datalog4.rule)(
+    "reachesStorage",
+    [(0, import_datalog4.variable)("f")],
+    [(0, import_datalog4.lit)("defCallsName", (0, import_datalog4.variable)("f"), (0, import_datalog4.variable)("m")), (0, import_datalog4.lit)("reachesStorage", (0, import_datalog4.variable)("m"))]
+  )
+];
+function functionsReachingStorage(db, definitions, couldMatch) {
   for (const node of definitions.values()) {
     const name = field(node, "name");
     if (name === null) {
       continue;
     }
-    bodies.push({ name: name.text, calls: callsUnder(node).map(calledName) });
-  }
-  const reaching = /* @__PURE__ */ new Set();
-  for (const body of bodies) {
-    if (body.calls.some((called) => couldMatch.has(called))) {
-      reaching.add(body.name);
+    for (const called of callsUnder(node).map(calledName)) {
+      db.add("defCallsName", [name.text, called]);
     }
   }
-  for (let grew = true; grew; ) {
-    grew = false;
-    for (const body of bodies) {
-      if (reaching.has(body.name) || !body.calls.some((c) => reaching.has(c))) {
-        continue;
-      }
-      reaching.add(body.name);
-      grew = true;
-    }
+  for (const name of couldMatch) {
+    db.add("queryStart", [name]);
   }
-  return reaching;
+  (0, import_datalog4.evaluate)(db, REACHES_STORAGE_RULES);
+  return new Set(db.facts("reachesStorage").map((row) => String(row[0])));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {