@suss/adapter-python 0.7.2 → 0.9.0

package/dist/index.js

@@ -15703,7 +15703,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-TEXSN75M.js
+// ../../ir-core/dist/chunk-XUXN6DIX.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -15713,6 +15713,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;
 }
@@ -15750,6 +15753,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,
@@ -15782,6 +15788,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
@@ -15812,6 +15822,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,
@@ -15847,13 +15860,19 @@ 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",
     "kafka",
-    "nats"
+    "nats",
+    "cloudflare-queues",
+    "cloudflare-cron",
+    "cloudflare-tail"
   ]),
   /**
    * Stable channel identifier: a CFN logical id, a queue or topic name,
@@ -15866,6 +15885,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,
@@ -15923,6 +15946,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"),
   /**
@@ -15978,6 +16031,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,
@@ -16053,7 +16114,8 @@ var DeployableUnitSchema = external_exports.object({
     "lambda",
     "ecs-task",
     "container",
-    "k8s-deployment"
+    "k8s-deployment",
+    "worker"
   ]),
   // An empty name would agree with every other empty name, so a unit
   // with no name has to leave the field off instead.
@@ -16065,6 +16127,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,
@@ -16075,9 +16141,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(),
   /**
@@ -16105,6 +16171,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,
@@ -16119,7 +16193,8 @@ var SemanticsSchema = external_exports.discriminatedUnion("name", [
   graphqlOperationSemantics.schema,
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
-  messageBusSemantics.schema
+  messageBusSemantics.schema,
+  metricSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -16128,7 +16203,8 @@ var DEFINITIONS = [
   graphqlOperationSemantics,
   runtimeConfigSemantics,
   storageSemantics,
-  messageBusSemantics
+  messageBusSemantics,
+  metricSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
@@ -16362,36 +16438,203 @@ function statementIn(call) {
 import { deriveOnDemand, evaluate } from "@suss/datalog";
 
 // ../../resolution/dist/index.js
-import { lit, rule, variable as v } from "@suss/datalog";
+import { constant, lit, rule, variable as v } from "@suss/datalog";
+var VALUE_STEP = constant("value");
+var RESULT_STEP = 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.
+  rule("stepsTo", [v("x"), v("y"), VALUE_STEP], [lit("binds", v("x"), v("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.
+  rule(
+    "stepsTo",
+    [v("x"), v("y"), VALUE_STEP],
+    [lit("endsHolding", v("x"), v("y"))]
+  ),
+  // An import steps to what the module exports under that name.
+  rule(
+    "stepsTo",
+    [v("x"), v("value"), VALUE_STEP],
+    [
+      lit("imports", v("x"), v("m"), v("n")),
+      lit("moduleExport", v("m"), v("n"), v("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`.
+  rule(
+    "stepsTo",
+    [v("p"), v("a"), VALUE_STEP],
+    [lit("passesArgument", v("r"), v("p"), v("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.
+  rule(
+    "stepsTo",
+    [v("x"), v("held"), VALUE_STEP],
+    [
+      lit("readsProperty", v("x"), v("o"), v("n")),
+      lit("objectOf", v("o"), v("obj")),
+      lit("contains", v("obj"), v("n"), v("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.
+  rule(
+    "stepsTo",
+    [v("r"), v("cls"), VALUE_STEP],
+    [
+      lit("call", v("r"), v("c")),
+      lit("comesTo", v("c"), v("cls")),
+      lit("objectValue", v("cls"))
+    ]
+  ),
+  // Wrapper transparency, derived: calling a factory that returns a
+  // function which calls its parameter k steps to argument k.
+  rule(
+    "stepsTo",
+    [v("r"), v("a"), VALUE_STEP],
+    [
+      lit("call", v("r"), v("c")),
+      lit("comesTo", v("c"), v("f")),
+      lit("unwraps", v("f"), v("k")),
+      lit("callArg", v("r"), v("k"), v("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.
+  rule(
+    "stepsTo",
+    [v("r"), v("a"), VALUE_STEP],
+    [
+      lit("calleeName", v("r"), v("n")),
+      lit("unwrapsByName", v("n"), v("k")),
+      lit("wrapperModule", v("n"), v("m")),
+      lit("calleeOrigin", v("r"), v("m")),
+      lit("callArg", v("r"), v("k"), v("a"))
+    ]
+  ),
+  // The one step that runs a function forwards: a call steps to what
+  // the function it invokes returns.
+  rule(
+    "stepsTo",
+    [v("r"), v("ret"), RESULT_STEP],
+    [lit("invokes", v("r"), v("f")), lit("returnsValue", v("f"), v("ret"))]
+  ),
+  // 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.
+  rule(
+    "reaches",
+    [v("x"), v("z"), v("kind")],
+    [lit("stepsTo", v("x"), v("z"), v("kind"))]
+  ),
+  rule(
+    "reaches",
+    [v("x"), v("z"), v("kind")],
+    [
+      lit("stepsTo", v("x"), v("y"), VALUE_STEP),
+      lit("reaches", v("y"), v("z"), v("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.
+  rule(
+    "reaches",
+    [v("x"), v("z"), RESULT_STEP],
+    [
+      lit("stepsTo", v("x"), v("y"), RESULT_STEP),
+      lit("reaches", v("y"), v("z"), VALUE_STEP)
+    ]
+  ),
+  rule(
+    "reaches",
+    [v("x"), v("z"), RESULT_STEP],
+    [
+      lit("stepsTo", v("x"), v("y"), RESULT_STEP),
+      lit("reaches", v("y"), v("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.
   rule("comesTo", [v("x"), v("x")], [lit("func", v("x"))]),
   rule("comesTo", [v("x"), v("x")], [lit("objectValue", v("x"))]),
-  // Aliasing: const x = y, or an identifier referencing a declaration.
   rule(
     "comesTo",
     [v("x"), v("z")],
-    [lit("binds", v("x"), v("y")), lit("comesTo", v("y"), v("z"))]
+    [lit("reaches", v("x"), v("z"), VALUE_STEP), lit("func", v("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.
   rule(
     "comesTo",
     [v("x"), v("z")],
-    [lit("endsHolding", v("x"), v("y")), lit("comesTo", v("y"), v("z"))]
+    [lit("reaches", v("x"), v("z"), VALUE_STEP), lit("objectValue", v("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.
   rule(
-    "comesTo",
+    "givesBack",
+    [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), RESULT_STEP), lit("func", v("z"))]
+  ),
+  rule(
+    "givesBack",
     [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), RESULT_STEP), lit("objectValue", v("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.
+  rule("isWrittenAs", [v("x"), v("x")], [lit("writtenValue", v("x"))]),
+  rule("isWrittenAs", [v("x"), v("x")], [lit("objectValue", v("x"))]),
+  rule(
+    "isWrittenAs",
+    [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), VALUE_STEP), lit("writtenValue", v("z"))]
+  ),
+  rule(
+    "isWrittenAs",
+    [v("x"), v("z")],
+    [lit("reaches", v("x"), v("z"), VALUE_STEP), lit("objectValue", v("z"))]
+  ),
+  // What one call site put in a parameter, told apart from what the
+  // other callers passed.
+  rule(
+    "paramAt",
+    [v("r"), v("p"), v("z")],
     [
-      lit("imports", v("x"), v("m"), v("n")),
-      lit("moduleExport", v("m"), v("n"), v("value")),
-      lit("comesTo", v("value"), v("z"))
+      lit("passesArgument", v("r"), v("p"), v("a")),
+      lit("comesTo", v("a"), v("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.
+  rule(
+    "passesArgument",
+    [v("r"), v("p"), v("a")],
+    [
+      lit("paramOf", v("f"), v("k"), v("p")),
+      lit("callsFunction", v("r"), v("f")),
+      lit("callArg", v("r"), v("k"), v("a"))
+    ]
+  ),
+  rule(
+    "passesArgument",
+    [v("r"), v("p"), v("a")],
+    [
+      lit("paramNamed", v("f"), v("n"), v("p")),
+      lit("callsFunction", v("r"), v("f")),
+      lit("callKeywordArg", v("r"), v("n"), v("a"))
     ]
   ),
   // What a module exports: directly, or through re-export chains.
@@ -16416,12 +16659,22 @@ var RESOLUTION_RULES = [
       lit("moduleExport", v("m2"), v("n"), v("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.
+  rule(
+    "invokes",
+    [v("r"), v("f")],
+    [lit("call", v("r"), v("c")), lit("comesTo", v("c"), v("f"))]
+  ),
+  // The callee is itself a call: `daoBuilder()()`.
+  rule(
+    "invokes",
+    [v("r"), v("f")],
+    [lit("call", v("r"), v("c")), lit("givesBack", v("c"), v("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.
   rule(
     "objectOf",
     [v("o"), v("obj")],
@@ -16429,14 +16682,8 @@ var RESOLUTION_RULES = [
   ),
   rule(
     "objectOf",
-    [v("r"), v("obj")],
-    [
-      lit("call", v("r"), v("c")),
-      lit("comesTo", v("c"), v("f")),
-      lit("returnsValue", v("f"), v("ret")),
-      lit("comesTo", v("ret"), v("obj")),
-      lit("objectValue", v("obj"))
-    ]
+    [v("x"), v("obj")],
+    [lit("givesBack", v("x"), v("obj")), lit("objectValue", v("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
@@ -16457,40 +16704,16 @@ var RESOLUTION_RULES = [
       lit("call", v("r"), v("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.
-  rule(
-    "objectOf",
-    [v("r"), v("obj")],
-    [
-      lit("call", v("r"), v("c")),
-      lit("comesTo", v("c"), v("f")),
-      lit("returnsValue", v("f"), v("ret")),
-      lit("objectOf", v("ret"), v("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.
-  rule(
-    "comesTo",
-    [v("p"), v("z")],
-    [
-      lit("paramOf", v("f"), v("k"), v("p")),
-      lit("callsFunction", v("r"), v("f")),
-      lit("callArg", v("r"), v("k"), v("a")),
-      lit("comesTo", v("a"), v("z"))
-    ]
-  ),
+  // 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.
   rule(
-    "comesTo",
-    [v("p"), v("z")],
+    "callsFunction",
+    [v("r"), v("f")],
     [
-      lit("paramNamed", v("f"), v("n"), v("p")),
-      lit("callsFunction", v("r"), v("f")),
-      lit("callKeywordArg", v("r"), v("n"), v("a")),
-      lit("comesTo", v("a"), v("z"))
+      lit("moduleExport", v("m"), v("n"), v("f")),
+      lit("imports", v("d"), v("m"), v("n")),
+      lit("binds", v("c"), v("d")),
+      lit("call", v("r"), v("c"))
     ]
   ),
   // What an object contains, its base class included, so a method the base
@@ -16512,33 +16735,8 @@ var RESOLUTION_RULES = [
       lit("contains", v("baseCls"), v("n"), v("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.
-  rule(
-    "comesTo",
-    [v("r"), v("cls")],
-    [
-      lit("call", v("r"), v("c")),
-      lit("comesTo", v("c"), v("cls")),
-      lit("objectValue", v("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.
-  rule(
-    "comesTo",
-    [v("x"), v("z")],
-    [
-      lit("readsProperty", v("x"), v("o"), v("n")),
-      lit("objectOf", v("o"), v("obj")),
-      lit("contains", v("obj"), v("n"), v("held")),
-      lit("comesTo", v("held"), v("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.
   rule(
     "returnsFunc",
     [v("f"), v("g")],
@@ -16599,56 +16797,20 @@ var RESOLUTION_RULES = [
       lit("paramOf", v("f"), v("k"), v("p"))
     ]
   ),
-  rule(
-    "comesTo",
-    [v("r"), v("h")],
-    [
-      lit("call", v("r"), v("c")),
-      lit("comesTo", v("c"), v("f")),
-      lit("unwraps", v("f"), v("k")),
-      lit("callArg", v("r"), v("k"), v("a")),
-      lit("comesTo", v("a"), v("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.
-  rule(
-    "comesTo",
-    [v("r"), v("h")],
-    [
-      lit("calleeName", v("r"), v("n")),
-      lit("unwrapsByName", v("n"), v("k")),
-      lit("wrapperModule", v("n"), v("m")),
-      lit("calleeOrigin", v("r"), v("m")),
-      lit("callArg", v("r"), v("k"), v("a")),
-      lit("comesTo", v("a"), v("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.
   rule(
     "comesFrom",
     [v("x"), v("m"), v("n")],
     [lit("imports", v("x"), v("m"), v("n"))]
   ),
-  rule(
-    "comesFrom",
-    [v("x"), v("m"), v("n")],
-    [lit("binds", v("x"), v("y")), lit("comesFrom", v("y"), v("m"), v("n"))]
-  ),
   rule(
     "comesFrom",
     [v("x"), v("m"), v("n")],
     [
-      lit("imports", v("x"), v("m2"), v("n2")),
-      lit("moduleExport", v("m2"), v("n2"), v("value")),
-      lit("comesFrom", v("value"), v("m"), v("n"))
+      lit("reaches", v("x"), v("y"), VALUE_STEP),
+      lit("imports", v("y"), v("m"), v("n"))
     ]
   ),
   // Calling f ends up calling the name n that module m exports. One hop
@@ -16684,36 +16846,6 @@ var RESOLUTION_RULES = [
     "resolves",
     [v("x"), v("z")],
     [lit("comesTo", v("x"), v("z")), lit("func", v("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.
-  rule("isWrittenAs", [v("x"), v("x")], [lit("writtenValue", v("x"))]),
-  rule("isWrittenAs", [v("x"), v("x")], [lit("objectValue", v("x"))]),
-  rule(
-    "isWrittenAs",
-    [v("x"), v("z")],
-    [lit("binds", v("x"), v("y")), lit("isWrittenAs", v("y"), v("z"))]
-  ),
-  rule(
-    "isWrittenAs",
-    [v("x"), v("z")],
-    [lit("endsHolding", v("x"), v("y")), lit("isWrittenAs", v("y"), v("z"))]
-  ),
-  rule(
-    "isWrittenAs",
-    [v("x"), v("z")],
-    [
-      lit("imports", v("x"), v("m"), v("n")),
-      lit("moduleExport", v("m"), v("n"), v("value")),
-      lit("isWrittenAs", v("value"), v("z"))
-    ]
   )
 ];
 var RESOLUTION_QUESTIONS = [
@@ -16745,6 +16877,13 @@ var RESOLUTION_QUESTIONS = [
     [v("x"), v("z")],
     [lit("wanted", v("x")), lit("objectOf", v("x"), v("z"))]
   ),
+  // Keyed by the parameter, since that is what a caller has in hand
+  // when it wants the call sites told apart.
+  rule(
+    "wantedParamAt",
+    [v("p"), v("r"), v("z")],
+    [lit("wanted", v("p")), lit("paramAt", v("r"), v("p"), v("z"))]
+  ),
   rule(
     "wantedComesFrom",
     [v("x"), v("m"), v("n")],