@suss/adapter-python 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -15747,7 +15747,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-WRRENYBR.js
+// ../../ir-core/dist/chunk-XUXN6DIX.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -15757,6 +15757,9 @@ function fnIdentityKey(packageName, exportPath) {
 function busIdentityKey(messageBus, subject) {
   return `bus:${messageBus} ${subject}`;
 }
+function metricIdentityKey(metricSystem, metricType) {
+  return `metric:${metricSystem} ${metricType}`;
+}
 function defineBoundarySemantics(definition) {
   return definition;
 }
@@ -15794,6 +15797,9 @@ var FunctionCallSemanticsSchema = external_exports.object({
 var functionCallSemantics = defineBoundarySemantics({
   name: "function-call",
   schema: FunctionCallSemanticsSchema,
+  // A call that never leaves the process does not produce a span, and
+  // the conventions do not name one. All of it is ours.
+  semconv: {},
   behavior: {
     /** A call returns a value, which is not a status and a body. */
     exchangesHttpResponses: false,
@@ -15826,6 +15832,10 @@ var GraphqlOperationSemanticsSchema = external_exports.object({
 var graphqlOperationSemantics = defineBoundarySemantics({
   name: "graphql-operation",
   schema: GraphqlOperationSemanticsSchema,
+  semconv: {
+    operationName: { name: "graphql.operation.name" },
+    operationType: { name: "graphql.operation.type" }
+  },
   behavior: {
     /**
      * An operation gets a data-and-errors document back, which the
@@ -15856,6 +15866,9 @@ var GraphqlResolverSemanticsSchema = external_exports.object({
 var graphqlResolverSemantics = defineBoundarySemantics({
   name: "graphql-resolver",
   schema: GraphqlResolverSemanticsSchema,
+  // The conventions name the operation a client sent, not the
+  // resolver the server ran for one field of it.
+  semconv: {},
   behavior: {
     /** A resolver returns a field value, not a status and a body. */
     exchangesHttpResponses: false,
@@ -15891,8 +15904,11 @@ function channelsPair(a, b) {
 var MessageBusSemanticsSchema = external_exports.object({
   name: external_exports.literal("message-bus"),
   messageBus: external_exports.enum([
-    "sqs",
-    "sns",
+    // The conventions spell the two AWS buses this way, one with an
+    // underscore and one with a dot, so these are their strings and
+    // not a typo.
+    "aws_sqs",
+    "aws.sns",
     "s3",
     "eventbridge",
     "bullmq",
@@ -15913,6 +15929,10 @@ var MessageBusSemanticsSchema = external_exports.object({
 var messageBusSemantics = defineBoundarySemantics({
   name: "message-bus",
   schema: MessageBusSemanticsSchema,
+  semconv: {
+    messageBus: { name: "messaging.system" },
+    channel: { name: "messaging.destination.name" }
+  },
   behavior: {
     /** A message goes onto the channel and nothing comes back. */
     exchangesHttpResponses: false,
@@ -15970,6 +15990,36 @@ var messageBusSemantics = defineBoundarySemantics({
     }
   }
 });
+var MetricSemanticsSchema = external_exports.object({
+  name: external_exports.literal("metric"),
+  /** Which system the series lives in: cloud-monitoring, cloudwatch. */
+  metricSystem: external_exports.string(),
+  /**
+   * The type string the system knows the metric by, spelled the way
+   * both sides spell it. Null when the source states one this reader
+   * could not settle, as with a query it could not read: a metric
+   * nobody could name pairs with nothing rather than with whatever
+   * happens to share its source text.
+   */
+  metricType: external_exports.string().nullable()
+});
+var metricSemantics = defineBoundarySemantics({
+  name: "metric",
+  schema: MetricSemanticsSchema,
+  // OpenTelemetry knows a metric by its instrument name, and has no
+  // attribute for the system it lives in or the type string it goes by.
+  semconv: {},
+  behavior: {
+    exchangesHttpResponses: false,
+    reportsUnpairedItself: false,
+    identityKey(semantics) {
+      if (semantics.metricType === null) {
+        return null;
+      }
+      return metricIdentityKey(semantics.metricSystem, semantics.metricType);
+    }
+  }
+});
 var RestSemanticsSchema = external_exports.object({
   name: external_exports.literal("rest"),
   /**
@@ -16025,6 +16075,14 @@ function routePathAdmits(declaredPath, requestPath) {
 var restSemantics = defineBoundarySemantics({
   name: "rest",
   schema: RestSemanticsSchema,
+  semconv: {
+    // A span states the one method a request used, so a route that
+    // responds to every method has nothing to compare.
+    method: { name: "http.request.method", placeholderValues: ["*"] },
+    path: { name: "http.route" }
+    // declaredResponses is a list, and http.response.status_code is
+    // the one status a request got back.
+  },
   behavior: {
     /** A request goes out, a status and a body come back. */
     exchangesHttpResponses: true,
@@ -16113,6 +16171,10 @@ var RuntimeConfigSemanticsSchema = DeployableUnitSchema.extend({
 var runtimeConfigSemantics = defineBoundarySemantics({
   name: "runtime-config",
   schema: RuntimeConfigSemanticsSchema,
+  // service.name and cloud.resource_id name the same deployable, but
+  // instanceName is the deployment template's logical id, which is
+  // neither of those strings.
+  semconv: {},
   behavior: {
     /** A process reads its config at startup, and nothing replies. */
     exchangesHttpResponses: false,
@@ -16123,9 +16185,9 @@ var runtimeConfigSemantics = defineBoundarySemantics({
 var StorageSemanticsSchema = external_exports.object({
   name: external_exports.literal("storage"),
   /**
-   * Which store this is: postgres, mysql, sqlite, dynamodb. Two
-   * products' containers can share a name, so this keeps them apart,
-   * and it is what a finding message calls the store.
+   * Which store this is: postgresql, mysql, aws.dynamodb, or our own
+   * word for one OpenTelemetry never named, such as s3. Two products'
+   * containers can share a name, so this keeps them apart.
    */
   storageSystem: external_exports.string(),
   /**
@@ -16153,6 +16215,14 @@ var StorageSemanticsSchema = external_exports.object({
 var storageSemantics = defineBoundarySemantics({
   name: "storage",
   schema: StorageSemanticsSchema,
+  semconv: {
+    storageSystem: { name: "db.system.name" },
+    // "default" is our word for a source that named no database.
+    scope: { name: "db.namespace", placeholderValues: ["default"] },
+    container: { name: "db.collection.name" }
+    // A secondary index has no attribute of its own, so accessPath
+    // stays our word.
+  },
   behavior: {
     /** A query returns rows or items, not a status and a body. */
     exchangesHttpResponses: false,
@@ -16167,7 +16237,8 @@ var SemanticsSchema = external_exports.discriminatedUnion("name", [
   graphqlOperationSemantics.schema,
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
-  messageBusSemantics.schema
+  messageBusSemantics.schema,
+  metricSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -16176,7 +16247,8 @@ var DEFINITIONS = [
   graphqlOperationSemantics,
   runtimeConfigSemantics,
   storageSemantics,
-  messageBusSemantics
+  messageBusSemantics,
+  metricSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
@@ -16411,35 +16483,202 @@ var import_datalog2 = require("@suss/datalog");
 
 // ../../resolution/dist/index.js
 var import_datalog = require("@suss/datalog");
+var VALUE_STEP = (0, import_datalog.constant)("value");
+var RESULT_STEP = (0, import_datalog.constant)("result");
 var RESOLUTION_RULES = [
-  // A value comes to itself; every chain ends at something written out
-  // in source, a function or an object.
+  // Aliasing: const x = y, or an identifier referencing a declaration.
+  // A language with a hop of its own, like JavaScript's `.bind`, states
+  // it as a step too, or every question but `comesTo` misses it.
+  (0, import_datalog.rule)("stepsTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP], [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"))]),
+  // A name written more than once has the value the last write left
+  // there. The adapter works out which write that is and stays quiet
+  // when control flow decides, so such a name steps nowhere at all.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP],
+    [(0, import_datalog.lit)("endsHolding", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"))]
+  ),
+  // An import steps to what the module exports under that name.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("value"), VALUE_STEP],
+    [
+      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
+      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value"))
+    ]
+  ),
+  // A parameter steps to what a call passes it. A function called from
+  // several places leaves its parameter with more than one value, and a
+  // caller that needs those apart asks `paramAt`.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("a"), VALUE_STEP],
+    [(0, import_datalog.lit)("passesArgument", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a"))]
+  ),
+  // Reading a property steps to what the object contains under that
+  // name, whichever way the object arrived: `routes.list` off a name,
+  // or `make(body).handle` off a call.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("held"), VALUE_STEP],
+    [
+      (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("o"), (0, import_datalog.variable)("n")),
+      (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")),
+      (0, import_datalog.lit)("contains", (0, import_datalog.variable)("obj"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held"))
+    ]
+  ),
+  // Calling a class makes one of it, so the call steps to the class and
+  // a method read off the result is the one the class declares. The
+  // caveat below is about a factory function, and a class is not one.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("cls"), VALUE_STEP],
+    [
+      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
+      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("cls")),
+      (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("cls"))
+    ]
+  ),
+  // Wrapper transparency, derived: calling a factory that returns a
+  // function which calls its parameter k steps to argument k.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("a"), VALUE_STEP],
+    [
+      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
+      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
+      (0, import_datalog.lit)("unwraps", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")),
+      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
+    ]
+  ),
+  // Wrapper transparency, declared: a pack says this callee wraps
+  // argument k. The callee has to come from the library the pack said,
+  // so a local object spelled the same way is not mistaken for it.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("a"), VALUE_STEP],
+    [
+      (0, import_datalog.lit)("calleeName", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n")),
+      (0, import_datalog.lit)("unwrapsByName", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("k")),
+      (0, import_datalog.lit)("wrapperModule", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("m")),
+      (0, import_datalog.lit)("calleeOrigin", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("m")),
+      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
+    ]
+  ),
+  // The one step that runs a function forwards: a call steps to what
+  // the function it invokes returns.
+  (0, import_datalog.rule)(
+    "stepsTo",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("ret"), RESULT_STEP],
+    [(0, import_datalog.lit)("invokes", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")), (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("ret"))]
+  ),
+  // Where a walk gets to, and whether it ran a call on the way. A value
+  // step keeps whatever the rest of the walk was, and a result step
+  // makes the whole walk one that ran a call.
+  (0, import_datalog.rule)(
+    "reaches",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind")],
+    [(0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind"))]
+  ),
+  (0, import_datalog.rule)(
+    "reaches",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind")],
+    [
+      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP),
+      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), (0, import_datalog.variable)("kind"))
+    ]
+  ),
+  // Two rules rather than one leaving the rest of the walk's kind free.
+  // A free kind is a second question about the same relation, and a
+  // demand-driven run then derives both to answer either.
+  (0, import_datalog.rule)(
+    "reaches",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP],
+    [
+      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), RESULT_STEP),
+      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), VALUE_STEP)
+    ]
+  ),
+  (0, import_datalog.rule)(
+    "reaches",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP],
+    [
+      (0, import_datalog.lit)("stepsTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), RESULT_STEP),
+      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"), RESULT_STEP)
+    ]
+  ),
+  // What a value comes down to: the walk that never ran a call, stopped
+  // at a function or an object. Something already written out comes to
+  // itself, and every other walk ends at one of those.
   (0, import_datalog.rule)("comesTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("func", (0, import_datalog.variable)("x"))]),
   (0, import_datalog.rule)("comesTo", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("x"))]),
-  // Aliasing: const x = y, or an identifier referencing a declaration.
   (0, import_datalog.rule)(
     "comesTo",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
   ),
-  // A name written more than once has the value the last write left
-  // there, and `binds` says nothing about it. The adapter works out
-  // which write that is, in its own language's terms, and stays quiet
-  // when control flow decides. A name it stays quiet about comes to no
-  // value, which is the answer.
   (0, import_datalog.rule)(
     "comesTo",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("endsHolding", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"))]
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
   ),
-  // An import comes to what the module exports under that name.
+  // The same stopping condition, for the walk that ran a call. A call
+  // gets no `comesTo` answer on purpose: coming back with what a
+  // factory returned would fight the unwrapping answer.
   (0, import_datalog.rule)(
-    "comesTo",
+    "givesBack",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
+  ),
+  (0, import_datalog.rule)(
+    "givesBack",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), RESULT_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
+  ),
+  // Following a value to the expression it is written as, whatever kind
+  // that is. A GraphQL document is neither a function nor an object, so
+  // `comesTo` never reaches one.
+  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("writtenValue", (0, import_datalog.variable)("x"))]),
+  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("x"))]),
+  (0, import_datalog.rule)(
+    "isWrittenAs",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("writtenValue", (0, import_datalog.variable)("z"))]
+  ),
+  (0, import_datalog.rule)(
+    "isWrittenAs",
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"), VALUE_STEP), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("z"))]
+  ),
+  // What one call site put in a parameter, told apart from what the
+  // other callers passed.
+  (0, import_datalog.rule)(
+    "paramAt",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("z")],
     [
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("value"), (0, import_datalog.variable)("z"))
+      (0, import_datalog.lit)("passesArgument", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")),
+      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("z"))
+    ]
+  ),
+  // An argument arriving at the parameter it is passed to, by position
+  // or by the name the caller wrote, keeping the call it went through
+  // so `paramAt` can tell two call sites apart.
+  (0, import_datalog.rule)(
+    "passesArgument",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")],
+    [
+      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p")),
+      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
+      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a"))
+    ]
+  ),
+  (0, import_datalog.rule)(
+    "passesArgument",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("a")],
+    [
+      (0, import_datalog.lit)("paramNamed", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("p")),
+      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
+      (0, import_datalog.lit)("callKeywordArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("a"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
@@ -16464,12 +16703,22 @@ var RESOLUTION_RULES = [
       (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value"))
     ]
   ),
-  // The object an expression refers to. A name arrives at one by
-  // following `comesTo` through aliases and imports. A factory call
-  // arrives at one through what the function it calls returns; the
-  // call itself is given no `comesTo`, since a factory call usually IS
-  // the wrapper and answering with the raw returned function would
-  // fight the unwraps answer.
+  // The function a call runs, written from the call's side because a
+  // caller asking what a call gives back has the call in hand.
+  (0, import_datalog.rule)(
+    "invokes",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
+    [(0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")), (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f"))]
+  ),
+  // The callee is itself a call: `daoBuilder()()`.
+  (0, import_datalog.rule)(
+    "invokes",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")],
+    [(0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")), (0, import_datalog.lit)("givesBack", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f"))]
+  ),
+  // The object an expression refers to: a name through `comesTo`, a
+  // factory call through what it gives back. Naming the step is what
+  // makes `routes.list` and `make(body).handle` one rule.
   (0, import_datalog.rule)(
     "objectOf",
     [(0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")],
@@ -16477,14 +16726,8 @@ var RESOLUTION_RULES = [
   ),
   (0, import_datalog.rule)(
     "objectOf",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("obj")],
-    [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("ret")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("ret"), (0, import_datalog.variable)("obj")),
-      (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("obj"))
-    ]
+    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("obj")],
+    [(0, import_datalog.lit)("givesBack", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("obj")), (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("obj"))]
   ),
   // 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
@@ -16517,42 +16760,6 @@ var RESOLUTION_RULES = [
       (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c"))
     ]
   ),
-  // A function whose return is itself a call arrives at the same object
-  // that call does, so a chain passing through two factories settles.
-  (0, import_datalog.rule)(
-    "objectOf",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("obj")],
-    [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("returnsValue", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("ret")),
-      (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("ret"), (0, import_datalog.variable)("obj"))
-    ]
-  ),
-  // An argument reaches the parameter it is passed to, by position or
-  // by the name the caller wrote. A function called from several places
-  // leaves its parameter with more than one value, and the caller
-  // decides what to do about that.
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("z")],
-    [
-      (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("z"))
-    ]
-  ),
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("z")],
-    [
-      (0, import_datalog.lit)("paramNamed", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("p")),
-      (0, import_datalog.lit)("callsFunction", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("callKeywordArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("z"))
-    ]
-  ),
   // 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
@@ -16572,33 +16779,8 @@ var RESOLUTION_RULES = [
       (0, import_datalog.lit)("contains", (0, import_datalog.variable)("baseCls"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held"))
     ]
   ),
-  // Calling a class makes one of it, and reading a method off the
-  // result finds the method the class declares. The caveat above is
-  // about a factory function, and a class is not one.
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("cls")],
-    [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("cls")),
-      (0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("cls"))
-    ]
-  ),
-  // Reading a property comes to what the object holds under that name,
-  // whichever way the object arrived: `routes.list` off a name, or
-  // `make(body).handle` off a call.
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [
-      (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("o"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("obj")),
-      (0, import_datalog.lit)("contains", (0, import_datalog.variable)("obj"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("held")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("held"), (0, import_datalog.variable)("z"))
-    ]
-  ),
-  // Wrapper transparency, derived: calling a factory that returns a
-  // function which calls its parameter k comes to argument k.
+  // Which function a factory returns, and which of its parameters that
+  // function calls: together they are what makes it a wrapper.
   (0, import_datalog.rule)(
     "returnsFunc",
     [(0, import_datalog.variable)("f"), (0, import_datalog.variable)("g")],
@@ -16659,56 +16841,20 @@ var RESOLUTION_RULES = [
       (0, import_datalog.lit)("paramOf", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("p"))
     ]
   ),
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("h")],
-    [
-      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("f")),
-      (0, import_datalog.lit)("unwraps", (0, import_datalog.variable)("f"), (0, import_datalog.variable)("k")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("h"))
-    ]
-  ),
-  // Wrapper transparency, declared: a pack says this callee wraps
-  // argument k, whatever its implementation looks like. The callee has
-  // to have been imported from the library the pack named, so a local
-  // object spelled the same way is not mistaken for it.
-  (0, import_datalog.rule)(
-    "comesTo",
-    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("h")],
-    [
-      (0, import_datalog.lit)("calleeName", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("unwrapsByName", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("k")),
-      (0, import_datalog.lit)("wrapperModule", (0, import_datalog.variable)("n"), (0, import_datalog.variable)("m")),
-      (0, import_datalog.lit)("calleeOrigin", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("m")),
-      (0, import_datalog.lit)("callArg", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("k"), (0, import_datalog.variable)("a")),
-      (0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("a"), (0, import_datalog.variable)("h"))
-    ]
-  ),
   // Where a name comes from, when what it refers to lives outside the
-  // source being read. `comesTo` ends at something written out, so it
-  // never reaches a library's own function, and a project's alias of a
-  // library name has no answer at all. This follows the same aliases
-  // and barrels in the other direction and answers with the module and
-  // the name that module exports.
+  // source being read. A walk ends at something written out in source,
+  // so it never reaches a library's own function.
   (0, import_datalog.rule)(
     "comesFrom",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
     [(0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))]
   ),
-  (0, import_datalog.rule)(
-    "comesFrom",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
-    [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y")), (0, import_datalog.lit)("comesFrom", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))]
-  ),
   (0, import_datalog.rule)(
     "comesFrom",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],
     [
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n2")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m2"), (0, import_datalog.variable)("n2"), (0, import_datalog.variable)("value")),
-      (0, import_datalog.lit)("comesFrom", (0, import_datalog.variable)("value"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
+      (0, import_datalog.lit)("reaches", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y"), VALUE_STEP),
+      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"))
     ]
   ),
   // Calling f ends up calling the name n that module m exports. One hop
@@ -16744,36 +16890,6 @@ var RESOLUTION_RULES = [
     "resolves",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
     [(0, import_datalog.lit)("comesTo", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")), (0, import_datalog.lit)("func", (0, import_datalog.variable)("z"))]
-  ),
-  // Following a name to the expression it is written as. A separate
-  // relation rather than a widening of `comesTo`, so a caller asking
-  // the older question never sees a new answer: a factory call already
-  // has an unwrapping answer, and letting it also answer with itself
-  // would make that pair ambiguous.
-  //
-  // The two seeds are the two ways an expression can be written out. An
-  // object literal is one of them, and it is the shape a generated
-  // GraphQL document takes.
-  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("writtenValue", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)("isWrittenAs", [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("x")], [(0, import_datalog.lit)("objectValue", (0, import_datalog.variable)("x"))]),
-  (0, import_datalog.rule)(
-    "isWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("binds", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y")), (0, import_datalog.lit)("isWrittenAs", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"))]
-  ),
-  (0, import_datalog.rule)(
-    "isWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [(0, import_datalog.lit)("endsHolding", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("y")), (0, import_datalog.lit)("isWrittenAs", (0, import_datalog.variable)("y"), (0, import_datalog.variable)("z"))]
-  ),
-  (0, import_datalog.rule)(
-    "isWrittenAs",
-    [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
-    [
-      (0, import_datalog.lit)("imports", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")),
-      (0, import_datalog.lit)("moduleExport", (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n"), (0, import_datalog.variable)("value")),
-      (0, import_datalog.lit)("isWrittenAs", (0, import_datalog.variable)("value"), (0, import_datalog.variable)("z"))
-    ]
   )
 ];
 var RESOLUTION_QUESTIONS = [
@@ -16805,6 +16921,13 @@ var RESOLUTION_QUESTIONS = [
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("z")],
     [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("x")), (0, import_datalog.lit)("objectOf", (0, import_datalog.variable)("x"), (0, import_datalog.variable)("z"))]
   ),
+  // Keyed by the parameter, since that is what a caller has in hand
+  // when it wants the call sites told apart.
+  (0, import_datalog.rule)(
+    "wantedParamAt",
+    [(0, import_datalog.variable)("p"), (0, import_datalog.variable)("r"), (0, import_datalog.variable)("z")],
+    [(0, import_datalog.lit)("wanted", (0, import_datalog.variable)("p")), (0, import_datalog.lit)("paramAt", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("p"), (0, import_datalog.variable)("z"))]
+  ),
   (0, import_datalog.rule)(
     "wantedComesFrom",
     [(0, import_datalog.variable)("x"), (0, import_datalog.variable)("m"), (0, import_datalog.variable)("n")],