@suss/adapter-ruby 0.20.0 → 0.21.1

package/dist/index.cjs

@@ -72,12 +72,37 @@ function field(node, name) {
 function bodyStatements(body) {
   return body.namedChildren.filter((child) => child !== null);
 }
+var OWN_BODY_TYPES = /* @__PURE__ */ new Set([
+  "method",
+  "singleton_method",
+  "lambda",
+  "class",
+  "module",
+  "singleton_class"
+]);
+var ARGUMENT_LIST_TYPE = "argument_list";
+function runStatements(body, blockConfigures = () => false) {
+  const found = [];
+  const readsItsChildren = (node) => {
+    if (OWN_BODY_TYPES.has(node.type) || node.type === ARGUMENT_LIST_TYPE) {
+      return false;
+    }
+    return !(node.type === "call" && blockConfigures(node));
+  };
+  (0, import_extractor.walkDescendants)(body, null, {
+    at: (node) => {
+      found.push(node);
+    },
+    into: (node) => readsItsChildren(node) ? null : import_extractor.SKIP_CHILDREN
+  });
+  return found;
+}
 function symbolValue(node) {
   return node.type === "simple_symbol" ? node.text.slice(1) : null;
 }
 function instanceMethodsByName(body) {
   const methods = /* @__PURE__ */ new Map();
-  for (const stmt of bodyStatements(body)) {
+  for (const stmt of runStatements(body)) {
     if (stmt.type !== "method") {
       continue;
     }
@@ -90,7 +115,7 @@ function instanceMethodsByName(body) {
 }
 function bareCallArgumentGroups(body, name) {
   const groups = [];
-  for (const stmt of bodyStatements(body)) {
+  for (const stmt of runStatements(body)) {
     if (stmt.type !== "call" || field(stmt, "receiver") !== null) {
       continue;
     }
@@ -193,7 +218,7 @@ function walkClasses(root, visit) {
   });
 }
 function walkDefinitions(root, visit) {
-  walkBody(bodyStatements(root), [], visit);
+  walkBody(runStatements(root), [], visit);
 }
 function walkBody(statements, nesting, visit) {
   for (const stmt of statements) {
@@ -232,7 +257,7 @@ function visitClass(node, nesting, visit) {
     bodyNesting: identity.bodyNesting
   });
   if (bodyNode !== null) {
-    walkBody(bodyStatements(bodyNode), identity.bodyNesting, visit);
+    walkBody(runStatements(bodyNode), identity.bodyNesting, visit);
   }
 }
 function visitModule(node, nesting, visit) {
@@ -251,7 +276,7 @@ function visitModule(node, nesting, visit) {
     bodyNesting: identity.bodyNesting
   });
   if (bodyNode !== null) {
-    walkBody(bodyStatements(bodyNode), identity.bodyNesting, visit);
+    walkBody(runStatements(bodyNode), identity.bodyNesting, visit);
   }
 }
 function stripTypeSuffixName(qualifiedName) {
@@ -407,7 +432,7 @@ function definitionIn(blocks, name) {
   }
   return { method, dynamic };
 }
-function inheritedStatements(ancestry) {
+function inheritedStatements(ancestry, blockConfigures) {
   const statements = [];
   for (const entry of [...ancestry].reverse()) {
     if (entry.type !== "bodies") {
@@ -418,7 +443,7 @@ function inheritedStatements(ancestry) {
       if (body === null) {
         continue;
       }
-      for (const statement of bodyStatements(body)) {
+      for (const statement of runStatements(body, blockConfigures)) {
         statements.push({ block, statement });
       }
     }
@@ -644,14 +669,6 @@ function lowerRubyBody(body, terminals) {
 }
 
 // src/paths/effects.ts
-var DECLARATION_TYPES = /* @__PURE__ */ new Set([
-  "method",
-  "singleton_method",
-  "lambda",
-  "class",
-  "module",
-  "singleton_class"
-]);
 var RAISE_NAMES2 = /* @__PURE__ */ new Set(["raise", "fail"]);
 var BLOCK_TYPES = /* @__PURE__ */ new Set([
   "body_statement",
@@ -699,7 +716,7 @@ function isRaise2(node) {
 }
 function bodyCalls(node, found = []) {
   for (const child of children(node)) {
-    if (DECLARATION_TYPES.has(child.type)) {
+    if (OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
     if (child.type === "call" && !isPropertyRead(child) && !isRaise2(child)) {
@@ -15302,7 +15319,7 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../ir-core/dist/chunk-52CH76PE.js
+// ../../ir-core/dist/chunk-PPQWK62O.js
 function gqlIdentityKey(typeName, fieldName) {
   return `gql:${typeName}.${fieldName}`;
 }
@@ -15312,6 +15329,9 @@ function fnIdentityKey(packageName, exportPath) {
 function busIdentityKey(messageBus, subject) {
   return `bus:${messageBus} ${subject}`;
 }
+function unitIdentityKey(deploymentTarget, instanceName) {
+  return `unit:${deploymentTarget} ${instanceName}`;
+}
 function metricIdentityKey(metricSystem, metricType) {
   return `metric:${metricSystem} ${metricType}`;
 }
@@ -15585,6 +15605,42 @@ var metricSemantics = defineBoundarySemantics({
     }
   }
 });
+var HOLE_SPLIT = /(\{[^}]*\})/;
+function isHole(piece) {
+  return piece.startsWith("{") && piece.endsWith("}");
+}
+function parseBoundaryName(name) {
+  const parts = name.split(HOLE_SPLIT).filter((piece) => piece !== "").map(
+    (piece) => isHole(piece) ? { type: "hole", label: piece.slice(1, -1) } : { type: "text", text: piece }
+  );
+  const only = parts.length === 1 ? parts[0] : void 0;
+  if (only !== void 0 && only.type === "hole") {
+    return { type: "reference", path: only.label.split(".") };
+  }
+  if (parts.some((part) => part.type === "hole")) {
+    return { type: "pattern", parts };
+  }
+  return { type: "literal", value: name };
+}
+function patternHole(label) {
+  return `{${label}}`;
+}
+function namesNothing(name) {
+  return parseBoundaryName(name).type === "reference";
+}
+function referenceOf(name) {
+  if (name.type !== "reference") {
+    return null;
+  }
+  const root = name.path[0];
+  if (root === void 0 || name.path.some((part) => part === "")) {
+    return null;
+  }
+  return { root, fields: name.path.slice(1) };
+}
+function referenceFromName(name) {
+  return referenceOf(parseBoundaryName(name));
+}
 var SCHEME_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
 var PROTOCOL_RELATIVE_ORIGIN = /^\/\/[^/]*/;
 function pathAfterOrigin(text) {
@@ -15611,9 +15667,9 @@ var RestSemanticsSchema = external_exports.object({
   declaredResponses: external_exports.array(external_exports.number()).optional()
 });
 var OPENING_HOLE = /^\{([^{}]+)\}(.*)$/;
-function variableOf(label) {
-  const parts = label.split(".");
-  return parts[parts.length - 1] ?? label;
+function baseUrlReference(semantics) {
+  const label = OPENING_HOLE.exec(semantics.path ?? "")?.[1];
+  return label === void 0 ? null : referenceFromName(patternHole(label));
 }
 function normalizePath(path4) {
   let normalized = path4.replace(/:([a-zA-Z_]\w*)/g, "{$1}");
@@ -15724,6 +15780,14 @@ var restSemantics = defineBoundarySemantics({
       }
       return routePathAdmits(semantics.path, path4) ? "match" : "nomatch";
     },
+    /**
+     * A route the registration pattern admits is inside it. A route
+     * whose path this source never gave is left outside, because
+     * nothing here can show it is one the pattern covers.
+     */
+    withinScope(semantics, scope) {
+      return semantics.path !== null && routePathAdmits(scope, semantics.path);
+    },
     /**
      * A call whose base URL the deployment fills in, resolved to the
      * path it reaches.
@@ -15739,22 +15803,20 @@ var restSemantics = defineBoundarySemantics({
      * route parameter, and `/orders/{id}` means every id rather than a
      * variable somebody set.
      */
-    groundName(semantics, deployedAs) {
-      if (semantics.path === null) {
-        return null;
-      }
-      const opening = OPENING_HOLE.exec(semantics.path);
-      if (opening === null) {
+    groundName(semantics, deployment) {
+      const reference = baseUrlReference(semantics);
+      if (reference === null) {
         return null;
       }
-      const [, label, rest] = opening;
-      const base = deployedAs(variableOf(label));
+      const base = deployment.setTo(reference);
       if (base === null) {
         return null;
       }
+      const rest = OPENING_HOLE.exec(semantics.path ?? "")?.[2] ?? "";
       const grounded = pathAfterOrigin(`${base}${rest}`);
       return { ...semantics, path: grounded === "" ? "/" : grounded };
     },
+    nameReference: baseUrlReference,
     ruleBoundary: {
       // "METHOD /path": one leading token, then an absolute path.
       claims(raw) {
@@ -15830,6 +15892,9 @@ var StorageSemanticsSchema = external_exports.object({
    */
   accessPath: external_exports.string().nullable()
 });
+function containerReference(semantics) {
+  return semantics.container === null ? null : referenceFromName(semantics.container);
+}
 var storageSemantics = defineBoundarySemantics({
   name: "storage",
   schema: StorageSemanticsSchema,
@@ -15845,7 +15910,100 @@ var storageSemantics = defineBoundarySemantics({
     /** A query returns rows or items, not a status and a body. */
     exchangesHttpResponses: false,
     reportsUnpairedItself: false,
-    identityKey: () => null
+    identityKey: () => null,
+    displayLabel: storageLabel,
+    /**
+     * A container the source states as a variable is whatever the
+     * deployment sets that variable to. `{SUBSCRIBERS_TABLE}` in the
+     * code and `prod-subscribers-v1` in the manifest are one table.
+     */
+    groundName(semantics, deployment) {
+      const reference = containerReference(semantics);
+      if (reference === null) {
+        return null;
+      }
+      const name = deployment.setTo(reference);
+      return name === null ? null : { ...semantics, container: name };
+    },
+    nameReference: containerReference
+  }
+});
+function storageLabel(semantics) {
+  return `${semantics.storageSystem}:${storageContainerLabel(semantics)}`;
+}
+function storageContainerLabel(semantics) {
+  const container = semantics.container ?? "<unnamed container>";
+  const addressed = semantics.accessPath === null ? container : `${container}#${semantics.accessPath}`;
+  return semantics.scope === "default" ? addressed : `${semantics.scope}/${addressed}`;
+}
+var UnitInvocationSemanticsSchema = DeployableUnitSchema.extend({
+  name: external_exports.literal("unit-invocation"),
+  instanceName: DeployableUnitSchema.shape.instanceName.nullable()
+});
+function calleeReference(semantics) {
+  return semantics.instanceName === null ? null : referenceFromName(semantics.instanceName);
+}
+var unitInvocationSemantics = defineBoundarySemantics({
+  name: "unit-invocation",
+  schema: UnitInvocationSemanticsSchema,
+  // faas.name is the deployed function's own name and instanceName is
+  // the deployment template's logical id, which is a different string.
+  // Runtime config leaves the pair off for the same reason.
+  semconv: {},
+  behavior: {
+    /**
+     * A synchronous invoke gives back whatever the handler returned,
+     * which is a value rather than a status and a body. A handler's
+     * return only becomes an HTTP response under a proxy integration,
+     * and that route gets a REST binding instead of this one.
+     */
+    exchangesHttpResponses: false,
+    /**
+     * A unit nothing in the run invokes is the ordinary case, since
+     * most services are reached from a stack suss never read. So an
+     * uninvoked unit stays in the generic unmatched list rather than
+     * being reported as a problem here.
+     */
+    reportsUnpairedItself: false,
+    /**
+     * A callee the source states only as a variable is not a name for
+     * anything until the deployment fills it in, so it keys as nothing
+     * rather than as a bucket that would agree with itself alone.
+     */
+    identityKey(semantics) {
+      if (semantics.instanceName === null || namesNothing(semantics.instanceName)) {
+        return null;
+      }
+      return unitIdentityKey(
+        semantics.deploymentTarget,
+        semantics.instanceName
+      );
+    },
+    displayLabel(semantics) {
+      if (semantics.instanceName === null) {
+        return `unit:${semantics.deploymentTarget} (named at runtime)`;
+      }
+      return unitIdentityKey(
+        semantics.deploymentTarget,
+        semantics.instanceName
+      );
+    },
+    /**
+     * A call that reads its callee's name out of the environment
+     * reaches whichever resource the template wires that variable to.
+     * The logical id is the answer rather than the deployed name,
+     * because the invoked unit's own summary is keyed by the logical
+     * id and neither side ever writes the other's string.
+     */
+    groundName(semantics, deployment) {
+      const reference = calleeReference(semantics);
+      if (reference === null) {
+        return null;
+      }
+      const logicalId = deployment.pointsAt(reference);
+      return logicalId === null ? null : { ...semantics, instanceName: logicalId };
+    },
+    nameReference: calleeReference
   }
 });
 var SemanticsSchema = external_exports.discriminatedUnion("name", [
@@ -15856,7 +16014,8 @@ var SemanticsSchema = external_exports.discriminatedUnion("name", [
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
   messageBusSemantics.schema,
-  metricSemantics.schema
+  metricSemantics.schema,
+  unitInvocationSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -15866,7 +16025,8 @@ var DEFINITIONS = [
   runtimeConfigSemantics,
   storageSemantics,
   messageBusSemantics,
-  metricSemantics
+  metricSemantics,
+  unitInvocationSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
@@ -15956,6 +16116,13 @@ var TypeShapeSchema = external_exports.lazy(
 );
 
 // ../../ir-core/dist/index.js
+var RelationSchema = external_exports.enum([
+  "provides",
+  "reads",
+  "writes",
+  "invokes"
+]);
+var EffectRelationSchema = RelationSchema.exclude(["provides"]);
 var SuppressionSideSchema = external_exports.object({
   summary: external_exports.string().optional(),
   transitionId: external_exports.string().optional()
@@ -16144,9 +16311,9 @@ var RESOLUTION_RULES = [
     [(0, import_datalog2.lit)("invokes", (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("f")), (0, import_datalog2.lit)("returnsValue", (0, import_datalog2.variable)("f"), (0, import_datalog2.variable)("ret"))],
     "call result"
   ),
-  // Where a walk gets to, and whether it ran a call on the way. A value
-  // step keeps whatever the rest of the walk was, and a result step
-  // makes the whole walk one that ran a call.
+  // Where a walk gets to, and whether it ran a call on the way. The walk
+  // so far comes first, so demand stays on the value asked about; the
+  // README says what the other order cost.
   (0, import_datalog2.rule)(
     "reaches",
     [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind")],
@@ -16156,27 +16323,27 @@ var RESOLUTION_RULES = [
     "reaches",
     [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind")],
     [
-      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP),
-      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind"))
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), VALUE_STEP),
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), (0, import_datalog2.variable)("kind"))
     ]
   ),
-  // Two rules rather than one leaving the rest of the walk's kind free.
-  // A free kind is a second question about the same relation, and a
+  // Two rules rather than one leaving the next step's kind free. A free
+  // kind is a second question about the same relation, and a
   // demand-driven run then derives both to answer either.
   (0, import_datalog2.rule)(
     "reaches",
     [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
-      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), VALUE_STEP)
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), VALUE_STEP)
     ]
   ),
   (0, import_datalog2.rule)(
     "reaches",
     [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("z"), RESULT_STEP],
     [
-      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
-      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), RESULT_STEP)
+      (0, import_datalog2.lit)("reaches", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("y"), RESULT_STEP),
+      (0, import_datalog2.lit)("stepsTo", (0, import_datalog2.variable)("y"), (0, import_datalog2.variable)("z"), RESULT_STEP)
     ]
   ),
   // What a value comes down to: the walk that never ran a call, stopped
@@ -16522,29 +16689,14 @@ var RESOLUTION_QUESTIONS = [
   // 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"))]),
+  // The chain with at least one hop taken, which is what tells a
+  // destructured binding apart from asking about a node directly. The
+  // whole chain is the seed plus those hops.
   (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"))
-    ]
+    [(0, import_datalog2.lit)("callOriginChainStepped", (0, import_datalog2.variable)("x"), (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")],
@@ -16675,6 +16827,23 @@ var RESOLUTION_QUESTIONS = [
       (0, import_datalog2.lit)("callsInto", (0, import_datalog2.variable)("g"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n"))
     ]
   ),
+  // Subject identity, its own demand class; the README's subject
+  // section says why the origin pair rides on the written-value walk.
+  (0, import_datalog2.rule)(
+    "wantedSubjectWritten",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r")],
+    [(0, import_datalog2.lit)("wantedSubject", (0, import_datalog2.variable)("x")), (0, import_datalog2.lit)("isWrittenAs", (0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r"))]
+  ),
+  (0, import_datalog2.rule)(
+    "wantedSubjectConstruction",
+    [(0, import_datalog2.variable)("x"), (0, import_datalog2.variable)("r"), (0, import_datalog2.variable)("m"), (0, import_datalog2.variable)("n")],
+    [
+      (0, import_datalog2.lit)("wantedSubject", (0, import_datalog2.variable)("x")),
+      (0, import_datalog2.lit)("isWrittenAs", (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.lit)("comesFrom", (0, import_datalog2.variable)("c"), (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.
@@ -17022,7 +17191,10 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlock
   const knownClasses = ownBlocks[0]?.knownClasses ?? /* @__PURE__ */ new Set();
   const scope = { nesting: info.bodyNesting, knownClasses };
   const declsByName = /* @__PURE__ */ new Map();
-  for (const stmt of bodyStatements(info.bodyNode)) {
+  for (const stmt of runStatements(
+    info.bodyNode,
+    blockConfiguresCall(pattern)
+  )) {
     const decl = await readFieldCall(stmt, scope, ctx, ancestry);
     if (decl !== null) {
       declsByName.set(decl.fieldName, decl);
@@ -17032,6 +17204,17 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlock
     (decl) => buildFieldUnit(pack, typeName, decl, options.filePath)
   );
 }
+function blockConfiguresCall(pattern) {
+  const names = /* @__PURE__ */ new Set([
+    pattern.fieldCallName,
+    pattern.typeCallName,
+    pattern.argumentCallName
+  ]);
+  return (call) => {
+    const method = field(call, "method")?.text;
+    return field(call, "receiver") === null && method !== void 0 && names.has(method);
+  };
+}
 function branchesFor(body, range) {
   if (body.effects === void 0 && body.extraEffects === void 0) {
     return [];
@@ -17107,10 +17290,13 @@ async function readFieldCall(stmt, scope, ctx, ancestry) {
   }
   const callArgs = readCallArgs(field(stmt, "arguments"));
   const nameArg = callArgs.positional[0];
-  const symbol2 = nameArg !== void 0 ? symbolValue(nameArg) : null;
-  if (symbol2 === null) {
+  if (nameArg === void 0) {
     return null;
   }
+  const symbol2 = symbolValue(nameArg);
+  if (symbol2 === null) {
+    return computedNameDeclaration(stmt, nameArg);
+  }
   const read = await readFieldShape(
     symbol2,
     callArgs,
@@ -17121,11 +17307,29 @@ async function readFieldCall(stmt, scope, ctx, ancestry) {
   );
   return {
     fieldName: resolvedName(symbol2, callArgs, ctx.pattern),
+    namedOnTheWire: true,
     node: stmt,
     contract: read.contract,
     body: read.body
   };
 }
+function computedNameDeclaration(stmt, nameArg) {
+  const range = rangeOf(stmt);
+  return {
+    fieldName: nameArg.text,
+    namedOnTheWire: false,
+    node: stmt,
+    contract: null,
+    body: {
+      readings: [
+        (0, import_extractor3.unreadableReading)(
+          `This field is named by ${nameArg.text}, which is worked out when the class body runs, so the name the schema exposes it under was not read here`,
+          range
+        )
+      ]
+    }
+  };
+}
 function wiringReference(callArgs, wiringKeywords) {
   for (const keyword of wiringKeywords) {
     const ref = callArgs.keyword[keyword];
@@ -17250,7 +17454,10 @@ function readClassContract(ancestry, pattern) {
     args: /* @__PURE__ */ new Map()
   };
   const handlers = classCallHandlers(pattern);
-  for (const { block, statement } of inheritedStatements(ancestry)) {
+  for (const { block, statement } of inheritedStatements(
+    ancestry,
+    blockConfiguresCall(pattern)
+  )) {
     if (statement.type !== "call" || field(statement, "receiver") !== null) {
       continue;
     }
@@ -17341,12 +17548,12 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
       exportName: null,
       exportPath: null
     },
-    boundaryBinding: (0, import_behavioral_ir.graphqlResolverBinding)({
+    boundaryBinding: decl.namedOnTheWire ? (0, import_behavioral_ir.graphqlResolverBinding)({
       transport: pack.protocol,
       recognition: pack.name,
       typeName,
       fieldName: decl.fieldName
-    }),
+    }) : null,
     parameters,
     branches: branchesFor(decl.body, rangeOf(decl.node)),
     ...decl.body.bodyContent !== void 0 ? { bodyContent: decl.body.bodyContent } : {},
@@ -17417,14 +17624,6 @@ function nodeId(filePath, node) {
 function nameId(filePath, name) {
   return `${filePath}#${name}`;
 }
-var DECLARATION_TYPES2 = /* @__PURE__ */ new Set([
-  "method",
-  "singleton_method",
-  "lambda",
-  "class",
-  "module",
-  "singleton_class"
-]);
 var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
   "string",
   "integer",
@@ -17562,7 +17761,7 @@ function emitHash(emitter, hash2) {
 }
 function walkExpressions(node, visit) {
   for (const child of children3(node)) {
-    if (DECLARATION_TYPES2.has(child.type)) {
+    if (OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
     visit(child);
@@ -17620,7 +17819,7 @@ function emitMethodFacts(emitter, method) {
   }
   const recordNested = (node) => {
     for (const child of children3(node)) {
-      if (DECLARATION_TYPES2.has(child.type)) {
+      if (OWN_BODY_TYPES.has(child.type)) {
         add(emitter, "containsFn", funcKey, nodeId(emitter.filePath, child));
         continue;
       }

package/dist/index.d.cts

@@ -4,6 +4,16 @@ import { Database } from '@suss/datalog';
 import { TypeShape, BehavioralSummary } from '@suss/behavioral-ir';
 import { RawCodeStructure } from '@suss/extractor';
 
+/**
+ * A new `Parser` for every call, so that parses running at the same time do
+ * not fight over one parser's mutable `language` field. The compiled `Language`
+ * is loaded once per process and shared.
+ */
+declare function parseRuby(source: string): Promise<Tree>;
+
+/** A call whose block is the thing being configured rather than a place statements run. */
+type BlockConfigures = (call: Node) => boolean;
+
 /**
  * Finds the file behind a constant.
  *
@@ -19,13 +29,6 @@ declare function underscoreConstantPath(qualifiedName: string): string;
 /** Null when there is no file at that path. We do not fall back to another root or another spelling. */
 declare function resolveConstantFile(root: string, qualifiedName: string, convention: ConstantPathConvention): string | null;
 
-/**
- * A new `Parser` for every call, so that parses running at the same time do
- * not fight over one parser's mutable `language` field. The compiled `Language`
- * is loaded once per process and shared.
- */
-declare function parseRuby(source: string): Promise<Tree>;
-
 /**
  * Resolves Ruby constant paths against lexical nesting.
  *
@@ -65,7 +68,7 @@ interface ClassInfo {
     /** `Module.nesting` in effect inside this class's own body, innermost first. */
     bodyNesting: readonly string[];
 }
-/** Every `class` declaration reachable from `root` through direct module/class nesting, in source order. */
+/** Every `class` declaration reachable from `root` through module/class nesting, in source order. */
 declare function walkClasses(root: Node, visit: (info: ClassInfo) => void): void;
 /** The same walk including `module` declarations, for a lookup that has to reach a module's own methods. */
 declare function walkDefinitions(root: Node, visit: (info: ClassInfo) => void): void;
@@ -134,7 +137,7 @@ type MethodLookup = {
  */
 declare function methodInAncestry(ancestry: Ancestry, name: string): MethodLookup;
 /** Every statement of every body reached, most distant ancestor first, so a nearer declaration overwrites what it inherits. */
-declare function inheritedStatements(ancestry: Ancestry): Array<{
+declare function inheritedStatements(ancestry: Ancestry, blockConfigures?: BlockConfigures): Array<{
     block: ReachedBody;
     statement: Node;
 }>;