graph_weaver 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb688c1c86ee0e39da82446622479aeb99b887866326e892133efbabe8c5a3d
-  data.tar.gz: 9c5514556bbfb08b337d09be7df71d081eafe7b6ee678f658f5bf6086367fada
+  metadata.gz: e66ac94243bdc7f065534845a722bfd209c8d7b23a3a5fa1eff6041e3f563655
+  data.tar.gz: 413217dbda71c297abe537dc996b8e8413821365d9e966493bf7301d6351a6c7
 SHA512:
-  metadata.gz: 752fb13032272b5a9da29f549474444865a34552c336a32bb10316ec2c3bd38dd2996cc57604b30ca505ea35045f9abbd6d0bdefd0507d19714f3ab75f7dbc4d
-  data.tar.gz: ebce80c4ad9c3c471e086616f48afb83ea6e6741e7f1c44986bb5b7ba9f57112d144443e15a5b2b78e26297c20d2e2f8a9a4777559242a77f21ca2d4d25d1031
+  metadata.gz: 62dab00fca85973dbff0e695dcd9970a554ca98b6a717a375fa7f2cde349b2967672ce541bf108d3b058b54b47ce7d274f6c8f11f069360a59e95fcb86ff8ae5
+  data.tar.gz: 3a11e52459c3b0158d831c8815ced9c4ca5cd323435ffac4e36a8648e83179dd87763a4570aaa56b240d0d7d77d3b91e43d1706f40112d3eae2fa608950b797c

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+###  v0.3.0  (2026-07-28)
+- Renamed `register_type` to `extend_type` to disambiguate intent: it
+  *decorates* a generated struct with mixin modules/helpers — it doesn't
+  define or replace a type's deserialization (that's `register_scalar` /
+  `register_enum`, for leaf types, whose Ruby shape is fixed; a composite's
+  shape is per-query, so there's nothing fixed to replace). No deprecation —
+  the old name is dropped.
+- Invalid query input now raises `GraphWeaver::InputError` (under the
+  `GraphWeaver::Error` umbrella) instead of a raw `ArgumentError` /
+  `KeyError` / sorbet `TypeError`: an unknown or typo'd input key, a
+  missing required field, an out-of-range enum, or a wrong-typed field
+  when an input object is built from a hash through `coerce`. Carries
+  `#field` / `#struct` and a JSON-ready `#to_h` — one rescue point for
+  returning a 422 at an API boundary. Top-level *scalar* kwargs still
+  fail like any Ruby method call (sorbet `TypeError` / `ArgumentError`).
+
+###  v0.2.2  (2026-07-22)
+- Generated modules expose from_response / from_response! alongside
+  execute / execute!: deserialize a raw GraphQL response (fetched by any
+  client) into the typed envelope without going through the transport.
+  execute now delegates to from_response
+
 ###  v0.2.1  (2026-07-13)
 - Conventional paths are appendable lists: queries_paths /
   generated_paths (singular accessors read the first entry, so existing

data/CLAUDE.md

@@ -0,0 +1,70 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+A typed GraphQL client for Ruby: generates `# typed: strict` Ruby (nested
+`T::Struct`s + a typed `execute`) from your queries, checked against the schema
+at generation time. Sorbet is core to the product.
+
+## Sorbet typing policy — type by value, not for coverage
+
+Sorbet being core does **not** mean every file should be `# typed: strict`. Type
+where it pays off in developer experience; leave the rest at `# typed: true`.
+
+- **Strict (full sigs) — developer-facing contracts.** The types users touch:
+  `response.rb` (the envelope every `execute` returns), the error hierarchy
+  (`errors.rb`), and the **generated code** (emitted `# typed: strict`). Concrete
+  types here give downstream apps real call-site checking + autocomplete — that's
+  the product.
+- **`# typed: true` (loose) — dynamic / boundary internals.** The codegen
+  (`codegen.rb`, `codegen/nodes.rb`, `codegen/emit.rb`, `codegen/scalar_type.rb`,
+  `codegen/enum_type.rb`) walks graphql-ruby's approximately-typed AST and builds
+  modules/strings dynamically; `client.rb` wraps a graphql-ruby schema and a
+  duck-typed transport. Strict here is ~all `T.untyped` — paperwork that documents
+  shape without catching anything. **Don't promote these to strict.**
+- Rule of thumb: if a sig would be mostly `T.untyped`, it isn't worth writing.
+  Concrete types = value; `T.untyped` sigs = paperwork.
+- `railtie.rb` / `tasks.rb` are `# typed: ignore` (Rails/Rake DSL);
+  `directive_defaults_patch.rb` is `# typed: false` (a prepended monkeypatch).
+
+## Design invariants (don't "fix" these)
+
+- **The client slot is duck-typed.** A transport, `Retry`, a live graphql-ruby
+  schema class, or a test fake all satisfy one contract —
+  `execute(query, variables:) => {"data" => ..., "errors" => ...}` — with no
+  shared base class. **Don't formalize it as a strict Sorbet interface**: a
+  graphql-ruby `Schema` class fits the slot without inheriting anything, and a
+  strict interface would exclude it. This is why the transport/client seams stay
+  loosely typed.
+- **Codegen is query-driven.** Structs are generated per selection set, only for
+  the types a query actually touches — not the whole schema (so extra schema
+  types, e.g. federation `join__*`, generate no code).
+- **Leaf codecs vs composite decoration.** `register_scalar` / `register_enum`
+  *define/replace* how a leaf deserializes (its Ruby shape is fixed);
+  `extend_type` only *decorates* a generated composite struct with mixins — it
+  can't replace one, because a composite's shape varies per query. Don't add a
+  "replace a composite's deserializer" path.
+
+## Green before commit
+
+```sh
+bundle exec rspec        # full suite
+bundle exec srb tc       # Sorbet typecheck (CI gates on this too)
+```
+
+Both must pass. Sorbet sigs are runtime-checked by sorbet-runtime, so a wrong
+sig surfaces as an rspec failure, not only a `srb tc` error — a green suite
+validates the sigs against real usage.
+
+## Version bumps
+
+Bump `lib/graph_weaver/version.rb` and, in the **same commit**:
+
+- update `Gemfile.lock` (the gem pins its own version there; CI runs a frozen
+  `bundle install`, which fails at the *setup* step with exit code 16 — before
+  tests — if the lock is stale), and
+- add a `CHANGELOG.md` entry.
+
+`gem push` (the actual RubyGems release) is a separate, manual step.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graph_weaver (0.2.1)
+    graph_weaver (0.3.0)
       graphql (>= 2)
       sorbet-runtime
 
@@ -19,7 +19,6 @@ GEM
       irb (~> 1.10)
       reline (>= 0.3.8)
     diff-lcs (1.6.2)
-    docile (1.4.1)
     erb (6.0.4)
     erubi (1.13.1)
     faker (3.8.0)
@@ -43,7 +42,7 @@ GEM
     google-protobuf (4.35.1-x86_64-linux-gnu)
       bigdecimal
       rake (~> 13.3)
-    graphql (2.6.5)
+    graphql (2.6.6)
       base64
       fiber-storage
       logger
@@ -100,21 +99,16 @@ GEM
     rubydex (0.2.7-arm64-darwin)
     rubydex (0.2.7-x86_64-darwin)
     rubydex (0.2.7-x86_64-linux)
-    simplecov (0.22.0)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.2)
-    simplecov_json_formatter (0.1.4)
-    sorbet (0.6.13327)
-      sorbet-static (= 0.6.13327)
-    sorbet-runtime (0.6.13327)
-    sorbet-static (0.6.13327-aarch64-linux)
-    sorbet-static (0.6.13327-universal-darwin)
-    sorbet-static (0.6.13327-x86_64-linux)
-    sorbet-static-and-runtime (0.6.13327)
-      sorbet (= 0.6.13327)
-      sorbet-runtime (= 0.6.13327)
+    simplecov (1.0.2)
+    sorbet (0.6.13347)
+      sorbet-static (= 0.6.13347)
+    sorbet-runtime (0.6.13347)
+    sorbet-static (0.6.13347-aarch64-linux)
+    sorbet-static (0.6.13347-universal-darwin)
+    sorbet-static (0.6.13347-x86_64-linux)
+    sorbet-static-and-runtime (0.6.13347)
+      sorbet (= 0.6.13347)
+      sorbet-runtime (= 0.6.13347)
     spoom (1.8.3)
       erubi (>= 1.10.0)
       prism (>= 0.28.0)
@@ -172,7 +166,6 @@ CHECKSUMS
   concurrent-ruby (1.3.7) sha256=4412caec3a5ea2e5fdc52076724c071a81f2c0593d83b2ac8cbb8ca63b3151b0
   debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6
   diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
-  docile (1.4.1) sha256=96159be799bfa73cdb721b840e9802126e4e03dfc26863db73647204c727f21e
   erb (6.0.4) sha256=38e3803694be357fe2bfe312487c74beaf9fb4e5beb3e22498952fe1645b95d9
   erubi (1.13.1) sha256=a082103b0885dbc5ecf1172fede897f9ebdb745a4b97a5e8dc63953db1ee4ad9
   faker (3.8.0) sha256=c147b308df73a90f27a4fc84f18d4c22ef0ad9c2a64b2b61c86fd0ca71753efc
@@ -183,8 +176,8 @@ CHECKSUMS
   google-protobuf (4.35.1-arm64-darwin) sha256=d9c957df04fa89c749fa9a72a7b383eb4296efc9b2303dc6fd6fbe39c698ad6b
   google-protobuf (4.35.1-x86_64-darwin) sha256=66b62b4df00931018a692806df66393efa960d6d2b7da69735187249f950d3ee
   google-protobuf (4.35.1-x86_64-linux-gnu) sha256=c786439087512a3fbd199e9897d265b855f951d4027e218ea55e858d45969edd
-  graph_weaver (0.2.1)
-  graphql (2.6.5) sha256=1051825bfb4aedb4293cdbcd9726c3150e69e3512556609a32c2ca19d4be3d00
+  graph_weaver (0.3.0)
+  graphql (2.6.6) sha256=7438e2036b571c884377eb1529225470ba959365f26dc47152953c213bc38c31
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
   io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
   irb (1.18.0) sha256=de9454a0703a54704b9811a5ef31a60c86949fbf4013fcf244fabc7c775248e3
@@ -213,15 +206,13 @@ CHECKSUMS
   rubydex (0.2.7-arm64-darwin) sha256=f0d28bbf4153568be79b671642424750053e0bea971b60ddf5cec19bf4563990
   rubydex (0.2.7-x86_64-darwin) sha256=b002b259d118ac69de44470eff1597143318402c45630c47371f9542631447dc
   rubydex (0.2.7-x86_64-linux) sha256=dacfade9fa42ce4469618da6dac07e69d5f3ac6a313b4caced5234c8f052419a
-  simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5
-  simplecov-html (0.13.2) sha256=bd0b8e54e7c2d7685927e8d6286466359b6f16b18cb0df47b508e8d73c777246
-  simplecov_json_formatter (0.1.4) sha256=529418fbe8de1713ac2b2d612aa3daa56d316975d307244399fa4838c601b428
-  sorbet (0.6.13327) sha256=4b56cb04542661c6bf5075f1ca38ca00506045325fd689f460aee8466dd3d7a3
-  sorbet-runtime (0.6.13327) sha256=86f32b2df6d266bf5c0e0eb8ea81d0376ba36eece4c8610938174e403222948d
-  sorbet-static (0.6.13327-aarch64-linux) sha256=da8a575785d34641095631c50fe1d1f645ee8782c8e2aa5a0ecfd12d1fa22a8a
-  sorbet-static (0.6.13327-universal-darwin) sha256=a2a8c6b624aada3f6ef68852398de756248f71b3ea691119873515847010dcda
-  sorbet-static (0.6.13327-x86_64-linux) sha256=f3a915bab4af1979145c793a08d3b1db207526d5e2f332513da10a95e70f9028
-  sorbet-static-and-runtime (0.6.13327) sha256=7b039be023b6a7d2d17b1f751191f32307d9ace4170b6a192bb0e005d222e00e
+  simplecov (1.0.2) sha256=c6459434efe4b948b46477cc2df2faa73ab365f83a33c7c17f81262f4f7f1244
+  sorbet (0.6.13347) sha256=2830946e6efda8dc732c5d703350bed17f437fbea1ccfbef543a65e33ae445c1
+  sorbet-runtime (0.6.13347) sha256=54e7221d9f4b63f58aec79f3043752a9ba7810347c6ae0d903531591cc2d5f01
+  sorbet-static (0.6.13347-aarch64-linux) sha256=9bb60509bf9a8715d93e77cd55f96659575d81a5f47b52bd4f66b3dfe6f2182e
+  sorbet-static (0.6.13347-universal-darwin) sha256=d12678a45369dba9db724103d8badda995e66a83ae35798f68d804c46a6d3e45
+  sorbet-static (0.6.13347-x86_64-linux) sha256=5a4803d2ba4fc1964e23f3aa4073b224c345c2a72a5f5317623a4bae7ce2c8da
+  sorbet-static-and-runtime (0.6.13347) sha256=2130e3c20326948a3edd20385b444345cb7327eea9b141f373486e7c087a498d
   spoom (1.8.3) sha256=32871fa189bbfa49cf557a50f819f23cc9a6ceefd0346caa7a6adc193becd5dd
   tapioca (0.19.2) sha256=938731b07811aee8d23871b1aee8861d464fbaf2cfffbf79a62b0c869a5120ec
   thor (1.5.0) sha256=e3a9e55fe857e44859ce104a84675ab6e8cd59c650a49106a05f55f136425e73

data/README.md

@@ -113,6 +113,8 @@ api.execute!("query($id: ID!) { person(id: $id) { name } }", id: "1")
   `@skip`/`@include`, naming, clients, dynamic mode
 - **[Against a real API](docs/real_world.md)** — the exploratory tour:
   introspect a live endpoint (GitHub end to end), dynamic mode, schema caching
+- **[Federation](docs/federation.md)** — Apollo Federation: supergraph vs API
+  schema, feeding weaver a composed graph, the `@inaccessible` caveat
 - **[Transports](docs/transports.md)** — clients, the execute contract,
   Faraday, retries and backoff
 - **[Custom scalars](docs/scalars.md)** — the registry: codec inference,

data/docs/errors.md

@@ -31,6 +31,7 @@ it failed:
 | `ServerError` | reached it, non-2xx HTTP — `#status`, `#body` |
 | `QueryError` | 200 body with top-level GraphQL errors — `#errors`, `#data`, `#extensions`, `#codes` |
 | `TypeError` | the response wouldn't cast into the generated structs — `#struct`, `#cause` |
+| `InputError` | the variables wouldn't build into the generated input structs — unknown/typo'd key, missing required field, out-of-range enum, wrong-typed field — `#field`, `#struct` |
 | `ValidationError` | build time: the query didn't validate against the schema |
 
 ```ruby
@@ -64,11 +65,30 @@ Defaults match the rescue block above: transport failures always retry,
 override with `retry_if:`), and GraphQL-level codes only when listed in
 `retry_codes:`. Exhausting `tries:` re-raises the last error.
 
-Two deliberate exceptions live *outside* the hierarchy, because typed
-kwargs should fail like any Ruby method call: a wrong-typed variable
-raises sorbet-runtime's `TypeError` ("Parameter 'page': Expected type
-T.nilable(Integer), got type String"), and a missing required variable
-raises a plain `ArgumentError` ("missing keyword: :id").
+**Top-level scalar variables** fail like any Ruby method call, *outside* the
+hierarchy on purpose — passing the wrong Ruby type for a scalar kwarg is a
+programming bug, not caller input: a wrong-typed one raises sorbet-runtime's
+`TypeError` ("Parameter 'page': Expected type T.nilable(Integer), got type
+String"), a missing required one a plain `ArgumentError` ("missing keyword: :id").
+
+**Input-object variables** are the caller-input case, so they're *inside* the
+hierarchy. When you pass an input object as a hash (or struct) it's built
+through the generated `coerce`, and any problem there — an unknown/typo'd key, a
+missing required field, an out-of-range enum, a wrong-typed field — raises
+`GraphWeaver::InputError`. That's one rescue point for turning invalid input
+into a 422:
+
+```ruby
+rescue GraphWeaver::InputError => e
+  render json: e.to_h, status: :unprocessable_entity
+  # { "error" => "GraphWeaver::InputError",
+  #   "message" => "unknown key(s) for …Input: staus (did you mean 'status'?)",
+  #   "field" => "staus", "struct" => "…Input" }
+end
+```
+
+A nested filter reports the innermost input type, so the error points at the
+input that actually held the bad field.
 
 Business/validation failures returned *as data* (Shopify-style `userErrors { field
 message code }`) aren't errors here — they're just fields you selected, so they

data/docs/federation.md

@@ -0,0 +1,100 @@
+# Federation
+
+GraphWeaver generates a client for the **whole** graph, so with Apollo
+Federation you point it at the *composed* schema — the supergraph or the API
+schema — not at individual subgraph files.
+
+## The schema you feed it
+
+Three artifacts, easy to mix up:
+
+| Artifact | What it is | Feed to weaver? |
+|----------|------------|-----------------|
+| **Subgraph SDL** | one service's `.graphql`, with `@key`/`@shareable`/`extend schema @link` | No — it's a fragment of the graph, and its federation directives are declared elsewhere (imported via `@link`), so plain SDL loading rejects them |
+| **Supergraph** | the composed graph, annotated with `@join__*`/`@link` machinery | Yes — self-contained (see below) |
+| **API schema** | the supergraph with federation internals stripped — exactly what the router serves and what an introspection query returns | Yes — the exact client contract |
+
+`SchemaLoader.load` (and `Client.new(path_or_sdl)`) take the supergraph or the
+API schema as an SDL file or introspection dump; or point weaver at the router
+URL to introspect the API schema live.
+
+## Pointing weaver at a supergraph
+
+A supergraph SDL works as-is. It declares its own `@join__*`/`@link` directives
+and `join__*` types, so graphql-ruby builds it; weaver reads field types and
+args, not directives, so the join plumbing is ignored; and because codegen is
+**query-driven**, the federation-internal types generate no code unless a query
+names them (none would). Field shapes — nullability, args, enums, inputs — are
+identical to the API schema, so your generated structs are correct.
+
+The one caveat: a supergraph is a **superset** of the API schema, so weaver can
+only ever **over-permit** — it will never reject a valid query, but it won't
+flag one that selects a field the API *hides*. In practice that's exactly one
+thing: `@inaccessible`.
+
+### `@inaccessible`
+
+A federation-v2 directive marking an element as *present in the federated graph
+but removed from the public API schema*. Its common use is safely rolling out a
+change to a **shared type**: add the field to one subgraph marked
+`@inaccessible` (so composition doesn't require every subgraph to have it yet),
+roll it out to the rest, then drop the directive to publish it. (Apollo
+contracts also pair `@tag` + `@inaccessible` to build filtered API variants.)
+It's a fed-v2 feature — common in mature, multi-team graphs with lots of shared
+types, rare in small or young ones, and targeted where present (a handful of
+elements, not every field).
+
+Reading the raw supergraph, weaver would let you select an `@inaccessible`
+field — but the router serves the API schema and rejects it at runtime (a
+"field doesn't exist" error, surfaced as [`QueryError` / `schema_stale?`](errors.md)).
+So the gap is narrow (you'd have to query a hidden field on purpose) and fails
+loudly, not silently.
+
+One grep says whether it affects you at all:
+
+```sh
+grep -c '@inaccessible' supergraph.graphql
+```
+
+Zero, and the supergraph *is* the API schema for weaver's purposes — feed it
+directly.
+
+Other federation directives hide nothing from the schema:
+`@requiresScopes` / `@policy` / `@authenticated` keep the field and enforce
+access at runtime; `@tag` / `@requires` / `@provides` / `@external` are metadata
+weaver ignores.
+
+## The exact contract: the API schema
+
+To make codegen match the router precisely (no over-permit), feed weaver the
+**API schema** instead of the raw supergraph. Deriving it is a *subtraction*
+from the composed graph — not composition — done with Apollo's tooling:
+
+```sh
+rover supergraph compose --config supergraph.yaml > supergraph.graphql
+```
+
+```js
+// then, in JS, strip to the API schema:
+import { Supergraph } from '@apollo/federation-internals';
+import { printSchema } from 'graphql';
+
+const api = Supergraph.fromString(supergraphSdl).apiSchema().toGraphQLJSSchema();
+process.stdout.write(printSchema(api));   // api.graphql — feed this to weaver
+```
+
+Check the API SDL in (many teams already emit it in CI) and point weaver at it:
+codegen then validates against exactly what clients can query, with no live
+gateway involved.
+
+## Which to use
+
+- **No `@inaccessible`** → point weaver at the supergraph and move on.
+- **Uses `@inaccessible`, and you want codegen to catch hidden-field mistakes** →
+  feed the derived API schema (above), or introspect the live router.
+
+A large real supergraph carries more constructs than a toy one (interface
+objects via `@join__type(isInterfaceObject:)`, `@join__unionMember`, enum join
+directives). The mechanism holds, but the honest check is to run codegen against
+your actual composed schema plus a couple of representative queries before
+relying on it.

data/docs/generated_modules.md

@@ -119,6 +119,9 @@ module PersonQuery
   def self.client ...            # default client (see below)
   def self.execute(client = nil, id:)   # -> GraphWeaver::Response[Result]
   def self.execute!(client = nil, id:)  # -> Result, or raises QueryError
+
+  def self.from_response(response)      # deserialize a raw hash -> Response[Result]
+  def self.from_response!(response)     # -> Result, or raises QueryError
 end
 ```
 
@@ -127,6 +130,38 @@ end
   cost/throttle metadata survive.
 - `execute!` is the shortcut: the typed result or a raised
   `GraphWeaver::QueryError`.
+- `from_response` / `from_response!` are the **network-free half** of the
+  pair — same envelope, but from a response hash you already have (see below).
+
+## Deserializing a response from another client
+
+`execute` is two steps: make the request, then cast the JSON into the typed
+structs. Only the second step is GraphWeaver-specific, and it's exposed on its
+own — so you can fetch with any GraphQL client (Apollo, a raw `Net::HTTP` post,
+a batching layer, a recorded fixture) and hand the result to GraphWeaver:
+
+```ruby
+raw = my_graphql_client.post(PersonQuery::QUERY, id: "1")
+# => {"data" => {"person" => {...}}, "errors" => [...], "extensions" => {...}}
+
+response = PersonQuery.from_response(raw)   # GraphWeaver::Response[Result]
+person   = response.data!.person            # typed, no network
+
+# or skip the envelope:
+person   = PersonQuery.from_response!(raw).person
+```
+
+`from_response` builds the exact same `GraphWeaver::Response[Result]` envelope
+`execute` does — in fact `execute` *is* `from_response(transport.execute(...))`.
+Errors and extensions are preserved; `#data!` / `from_response!` raise
+`QueryError` on top-level errors.
+
+The one requirement: pass the response **verbatim** — a hash (or anything with
+`#to_h`) with the standard GraphQL shape and **wire-cased string keys**
+(`"person"`, `"nameWithOwner"`), the top-level `"data"` / `"errors"` /
+`"extensions"` keys included. Don't symbolize or snake_case it first;
+`from_response` reads `raw["data"]` and the casting reads camelCase field keys.
+The module must, of course, be generated for the query you ran.
 
 ## Variables become typed kwargs
 

data/docs/scalars.md

@@ -155,7 +155,7 @@ module PetHelpers
   def display_name = adult? ? "#{name} 🦴" : "#{name} 🐶"
 end
 
-GraphWeaver.register_type("Pet", PetHelpers)   # or api.register_type(...)
+GraphWeaver.extend_type("Pet", PetHelpers)   # or api.extend_type(...)
 
 pet.display_name   # => "Shelby 🦴"
 pet.name           # => "Shelby" — the wire value stays honest
@@ -173,7 +173,7 @@ For quick decoration, build the mixin inline — the block is
 `GraphWeaver::TypeHelpers` so generated files can reference it:
 
 ```ruby
-api.register_type("Pet") do
+api.extend_type("Pet") do
   def display_name = "#{name} 🐶"
 end
 ```

data/lib/graph_weaver/client.rb

@@ -101,8 +101,8 @@ class GraphWeaver::Client
   # Client-scoped type helpers: include app-owned modules into every
   # struct this client generates from the named GraphQL type — pass
   # modules, or a block to build one inline. Additive with global
-  # registrations (see GraphWeaver.register_type).
-  def register_type(graphql_name, *mixins, requires: nil, &block)
+  # registrations (see GraphWeaver.extend_type).
+  def extend_type(graphql_name, *mixins, requires: nil, &block)
     validate_registration!("type", graphql_name.to_s)
     entry = @types[graphql_name.to_s] ||= { mixins: [], requires: [] }
     GraphWeaver::Codegen.add_type_helpers(entry, graphql_name, mixins, requires, block)

data/lib/graph_weaver/codegen/emit.rb

@@ -409,7 +409,30 @@ class GraphWeaver::Codegen
 
       out << ""
       out << "    transport = GraphWeaver.resolve_transport(client || self.client)"
-      out << "    raw = transport.execute(QUERY, variables: variables).to_h"
+      out << "    from_response(transport.execute(QUERY, variables: variables))"
+      out << "  end"
+      out << ""
+      out << "  sig { params(#{sig_params.join(", ")}).returns(Result) }"
+      out << "  def self.execute!(#{kwargs.join(", ")})"
+      out << "    execute(#{forward}).data!"
+      out << "  end"
+      out << ""
+      emit_from_response(out)
+    end
+
+    # The network-free half of execute: deserialize a raw GraphQL response
+    # into the typed envelope. For responses fetched by any other client —
+    # execute delegates here after the transport call. Accepts the response
+    # hash (or anything with #to_h, e.g. a schema result): {"data" => ...,
+    # "errors" => ..., "extensions" => ...} with wire-cased string keys.
+    def emit_from_response(out)
+      out << "  # Deserialize a raw GraphQL response into the typed envelope — the"
+      out << "  # network-free half of execute, for responses fetched by any client."
+      out << "  # Takes the response hash (or anything with #to_h): {\"data\" => ...,"
+      out << "  # \"errors\" => ..., \"extensions\" => ...} with wire-cased string keys."
+      out << "  sig { params(response: T.untyped).returns(GraphWeaver::Response[Result]) }"
+      out << "  def self.from_response(response)"
+      out << "    raw = response.to_h"
       out << "    GraphWeaver::Response[Result].new("
       out << "      data: (Result.from_h(raw[\"data\"]) if raw[\"data\"]),"
       out << "      errors: (raw[\"errors\"] || []).map { |e| GraphWeaver::GraphQLError.from_h(e) },"
@@ -417,9 +440,10 @@ class GraphWeaver::Codegen
       out << "    )"
       out << "  end"
       out << ""
-      out << "  sig { params(#{sig_params.join(", ")}).returns(Result) }"
-      out << "  def self.execute!(#{kwargs.join(", ")})"
-      out << "    execute(#{forward}).data!"
+      out << "  # from_response + data! — the typed result, or a raised QueryError."
+      out << "  sig { params(response: T.untyped).returns(Result) }"
+      out << "  def self.from_response!(response)"
+      out << "    from_response(response).data!"
       out << "  end"
     end
 

data/lib/graph_weaver/codegen/enum_type.rb

@@ -90,19 +90,19 @@ class GraphWeaver::Codegen
     # Attach app-owned helper modules to every struct generated from a
     # GraphQL type — the logic stays in your code, generation wires it in:
     #
-    #      GraphWeaver.register_type("Pet", PetHelpers)
+    #      GraphWeaver.extend_type("Pet", PetHelpers)
     #
     # Or build the mixin inline — the block is module_eval'd into a fresh
     # module auto-named GraphWeaver::TypeHelpers::<Type>. Handy for quick
     # decoration; srb tc can't see into block-defined methods, so prefer
     # a named module where static checking matters:
     #
-    #      GraphWeaver.register_type("Pet") do
+    #      GraphWeaver.extend_type("Pet") do
     #        def display_name = "#{name} the pet"
     #      end
     #
     # Additive: repeated registrations (and client-scoped ones) stack.
-    def register_type(graphql_name, *mixins, requires: nil, &block)
+    def extend_type(graphql_name, *mixins, requires: nil, &block)
       entry = type_registry[graphql_name.to_s] ||= { mixins: [], requires: [] }
       add_type_helpers(entry, graphql_name, mixins, requires, block)
     end
@@ -111,7 +111,7 @@ class GraphWeaver::Codegen
       @type_registry ||= {}
     end
 
-    # shared with Client#register_type: build/validate the mixins and
+    # shared with Client#extend_type: build/validate the mixins and
     # append them to a registry entry
     def add_type_helpers(entry, graphql_name, mixins, requires, block)
       mixins = mixins.dup
@@ -143,7 +143,7 @@ class GraphWeaver::Codegen
 end
 
 module GraphWeaver
-  # Home of block-built type helpers (register_type with a block), which
+  # Home of block-built type helpers (extend_type with a block), which
   # need constant names so generated files can reference them.
   module TypeHelpers; end
 end

data/lib/graph_weaver/codegen/nodes.rb

@@ -147,7 +147,7 @@ class GraphWeaver::Codegen
 
     attr_reader :class_name, :fields
     # the GraphQL type this struct was generated from, and any registered
-    # helper modules to include (see Codegen.register_type)
+    # helper modules to include (see Codegen.extend_type)
     attr_accessor :graphql_type, :mixins
 
     def initialize(class_name)

data/lib/graph_weaver/codegen.rb

@@ -219,7 +219,9 @@ class GraphWeaver::Codegen
     suggestion = defined?(DidYouMean::SpellChecker) &&
       DidYouMean::SpellChecker.new(dictionary: schema.types.keys).correct(name).first
     hint = suggestion ? " — did you mean '#{suggestion}'?" : ""
-    raise GraphWeaver::Error, "register_#{kind}(#{name.inspect}) matches no type in this schema#{hint}"
+    # the type registry is reached via extend_type; scalars/enums via register_*
+    method = kind == "type" ? "extend_type" : "register_#{kind}"
+    raise GraphWeaver::Error, "#{method}(#{name.inspect}) matches no type in this schema#{hint}"
   end
 
   # Structured shape for a schema-validation error: message plus its first

data/lib/graph_weaver/errors.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -12,16 +12,20 @@ module GraphWeaver
   # structured failures to users. One subclass per failure site —
   # {TransportError} (never reached the server), {ServerError} (non-2xx),
   # {QueryError} (GraphQL-level errors), {TypeError} (response wouldn't
-  # cast), {ValidationError} (build time) — each merging its specifics
-  # into #to_h.
+  # cast), {InputError} (bad variables), {ValidationError} (build time) —
+  # each merging its specifics into #to_h.
   class Error < StandardError
+    extend T::Sig
+
     # every GraphWeaver error surfaces on the logger too (see
     # GraphWeaver.logger) — construction here means a raise
+    sig { params(args: T.untyped).void }
     def initialize(*args)
       super
       GraphWeaver.log(:warn) { "#{self.class.name}: #{message}" }
     end
 
+    sig { overridable.returns(T::Hash[String, T.untyped]) }
     def to_h
       { "error" => self.class.name, "message" => message }
     end
@@ -31,12 +35,17 @@ module GraphWeaver
   # TLS handshake, timeout. The original exception is preserved as #cause.
   # Generally retriable.
   class TransportError < Error
+    extend T::Sig
+
+    sig { override.returns(T::Hash[String, T.untyped]) }
     def to_h
       super.merge("cause" => cause&.class&.name)
     end
   end
 
   class << self
+    extend T::Sig
+
     # The exception classes the bundled transports reclassify as
     # TransportError — network-level failures where the request never
     # reached the server. A mutable Set: each transport contributes its own
@@ -48,11 +57,16 @@ module GraphWeaver
     #
     # SystemCallError covers every Errno::* (connection refused/reset, host
     # unreachable); SocketError covers DNS.
+    sig { returns(T::Set[T.class_of(Exception)]) }
     def transport_errors
-      @transport_errors ||= Set[SocketError, SystemCallError, IOError]
+      @transport_errors ||= T.let(
+        Set[SocketError, SystemCallError, IOError],
+        T.nilable(T::Set[T.class_of(Exception)]),
+      )
     end
 
     # Add one or more exception classes to the transport-error set.
+    sig { params(classes: T.class_of(Exception)).returns(T::Array[T.class_of(Exception)]) }
     def register_transport_error(*classes)
       transport_errors.merge(classes)
       classes
@@ -63,8 +77,15 @@ module GraphWeaver
   # that exploded, a 502 from a proxy, a 401, etc. Distinct from a GraphQL
   # error: we got an HTTP response, it just wasn't success.
   class ServerError < Error
-    attr_reader :status, :body
+    extend T::Sig
 
+    sig { returns(Integer) }
+    attr_reader :status
+
+    sig { returns(T.untyped) }
+    attr_reader :body
+
+    sig { params(status: Integer, body: T.untyped).void }
     def initialize(status:, body: nil)
       @status = status
       @body = body
@@ -72,6 +93,7 @@ module GraphWeaver
       super("HTTP #{status}#{snippet}")
     end
 
+    sig { override.returns(T::Hash[String, T.untyped]) }
     def to_h
       super.merge("status" => status)
     end
@@ -81,16 +103,38 @@ module GraphWeaver
   # object (not raised) — the response envelope and QueryError carry these.
   # Match on #code (extensions["code"]) rather than the message string.
   class GraphQLError
-    attr_reader :message, :locations, :path, :extensions
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(T::Array[T.untyped]) }
+    attr_reader :locations
 
+    sig { returns(T.nilable(T::Array[T.untyped])) }
+    attr_reader :path
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    attr_reader :extensions
+
+    sig do
+      params(
+        message: String,
+        locations: T::Array[T.untyped],
+        path: T.nilable(T::Array[T.untyped]),
+        extensions: T::Hash[String, T.untyped],
+        type: T.nilable(String),
+      ).void
+    end
     def initialize(message:, locations: [], path: nil, extensions: {}, type: nil)
       @message = message
       @locations = locations
       @path = path
       @extensions = extensions
-      @error_type = type
+      @error_type = T.let(type, T.nilable(String))
     end
 
+    sig { params(hash: T::Hash[String, T.untyped]).returns(GraphQLError) }
     def self.from_h(hash)
       new(
         message: hash["message"] || "(no message)",
@@ -105,6 +149,7 @@ module GraphWeaver
     # branch on. Read from extensions.code (the Apollo/spec-adjacent
     # convention) or a top-level "type" (GitHub's dialect: NOT_FOUND,
     # FORBIDDEN). nil when the server sent neither.
+    sig { returns(T.nilable(String)) }
     def code
       extensions["code"] || @error_type
     end
@@ -113,11 +158,15 @@ module GraphWeaver
     # (unknown field/type/argument). Heuristic by necessity: only Apollo
     # sets a standard code (GRAPHQL_VALIDATION_FAILED); graphql-ruby and
     # GitHub speak in messages.
-    VALIDATION_MESSAGE = /doesn't exist|Cannot query field|Unknown (field|type|argument)|isn't defined|undefined (field|type)/i
+    VALIDATION_MESSAGE = T.let(
+      /doesn't exist|Cannot query field|Unknown (field|type|argument)|isn't defined|undefined (field|type)/i,
+      Regexp,
+    )
 
     # True when this error looks like the server rejected the query's
     # shape — for a generated module that usually means the schema
     # changed after generation.
+    sig { returns(T::Boolean) }
     def validation?
       code == "GRAPHQL_VALIDATION_FAILED" || VALIDATION_MESSAGE.match?(message)
     end
@@ -126,17 +175,21 @@ module GraphWeaver
     # indices stripped — ["people", 3, "email"] => "people.email". The
     # parseable key for grouping/reporting (the raw #path keeps indices).
     # nil for global errors with no path.
+    sig { returns(T.nilable(String)) }
     def field
-      return unless path
+      p = path
+      return unless p
 
-      named = path.reject { |seg| seg.is_a?(Integer) || seg.to_s.match?(/\A\d+\z/) }
+      named = p.reject { |seg| seg.is_a?(Integer) || seg.to_s.match?(/\A\d+\z/) }
       named.join(".") unless named.empty?
     end
 
+    sig { returns(String) }
     def to_s
-      loc = locations&.first
+      loc = locations.first
       at = loc ? " at #{loc["line"]}:#{loc["column"]}" : ""
-      where = path ? " (path: #{path.join(".")})" : ""
+      p = path
+      where = p ? " (path: #{p.join(".")})" : ""
       tag = code ? " [#{code}]" : ""
       "#{message}#{at}#{where}#{tag}"
     end
@@ -144,6 +197,7 @@ module GraphWeaver
     # JSON-ready: the problematic field (both forms — #field for grouping,
     # #path with indices for exact location), the machine code, and the
     # server's full extensions.
+    sig { returns(T::Hash[String, T.untyped]) }
     def to_h
       {
         "message" => message,
@@ -158,15 +212,18 @@ module GraphWeaver
   end
 
   # Shared filtering over a collection of GraphQLErrors, for surfacing
-  # field-level failures programmatically. Host must define #errors.
+  # field-level failures programmatically. Host must define #errors / #data.
   module ErrorFiltering
+    extend T::Sig
     include Kernel # for sorbet: hosts are Objects
 
     # the host's interface, overridden by its attr_readers
+    sig { overridable.returns(T::Array[GraphQLError]) }
     def errors
       raise NotImplementedError, "#{self.class} must define #errors"
     end
 
+    sig { overridable.returns(T.untyped) }
     def data
       raise NotImplementedError, "#{self.class} must define #data"
     end
@@ -174,15 +231,20 @@ module GraphWeaver
     # Errors touching a field path — "user.email" or ["user", "email"];
     # prefix match, so deeper errors count too. List indices appear as
     # path segments ("people.0.email").
+    sig { params(path: T.any(String, T::Array[T.untyped])).returns(T::Array[GraphQLError]) }
     def errors_at(path)
       want = (path.is_a?(String) ? path.split(".") : path).map(&:to_s)
-      errors.select { |error| error.path && error.path.map(&:to_s).first(want.size) == want }
+      errors.select do |error|
+        p = error.path
+        p && p.map(&:to_s).first(want.size) == want
+      end
     end
 
     # True when any error looks like the server rejected the query's
     # shape — the schema has likely changed since the module was
     # generated. Refresh the schema dump and regenerate (rake
     # graph_weaver:schema:refresh && rake graph_weaver:generate).
+    sig { returns(T::Boolean) }
     def schema_stale?
       errors.any?(&:validation?)
     end
@@ -193,25 +255,31 @@ module GraphWeaver
     #      response.each_error do |field, errors|
     #        form.add_error(field, errors.map(&:message))
     #      end
+    sig { returns(T::Hash[T.nilable(String), T::Array[GraphQLError]]) }
     def errors_by_field
       errors.group_by(&:field)
     end
 
+    sig do
+      params(block: T.proc.params(field: T.nilable(String), errors: T::Array[GraphQLError]).void).void
+    end
     def each_error(&block)
-      errors_by_field.each(&block)
+      errors_by_field.each { |field, errs| block.call(field, errs) }
     end
 
     # The id of the record an error points into, resolved by walking the
     # error's path through the (partial) typed data: an error at
     # ["people", 3, "email"] resolves to people[3].id. nil when the data
     # is missing, the path doesn't walk, or the record has no id field.
+    sig { params(error: GraphQLError).returns(T.untyped) }
     def entity_id(error)
       # untyped by nature: the walk traverses whatever structs this query
       # generated, reassigning across types at each step
       node = T.let(data, T.untyped)
-      return unless node && error.path
+      path = error.path
+      return unless node && path
 
-      error.path[0..-2].each do |segment|
+      (path[0..-2] || []).each do |segment|
         node = if segment.is_a?(Integer) || segment.to_s.match?(/\A\d+\z/)
           node.is_a?(Array) ? node[segment.to_i] : nil
         else
@@ -230,6 +298,7 @@ module GraphWeaver
     #
     #      { "people.email" => { "messages" => [...], "codes" => [...],
     #        "entity_ids" => ["7", "9"], "errors" => [full to_h...] } }
+    sig { returns(T::Hash[T.nilable(String), T::Hash[String, T.untyped]]) }
     def report
       errors_by_field.to_h do |field, field_errors|
         [field, {
@@ -247,10 +316,25 @@ module GraphWeaver
   # Carries the structured errors, any partial data, and top-level
   # extensions (cost/throttle metadata).
   class QueryError < Error
+    extend T::Sig
     include ErrorFiltering
 
-    attr_reader :errors, :data, :extensions
+    sig { override.returns(T::Array[GraphQLError]) }
+    attr_reader :errors
+
+    sig { override.returns(T.untyped) }
+    attr_reader :data
 
+    sig { returns(T::Hash[String, T.untyped]) }
+    attr_reader :extensions
+
+    sig do
+      params(
+        errors: T::Array[GraphQLError],
+        data: T.untyped,
+        extensions: T::Hash[String, T.untyped],
+      ).void
+    end
     def initialize(errors, data: nil, extensions: {})
       @errors = errors
       @data = data
@@ -259,12 +343,14 @@ module GraphWeaver
     end
 
     # All non-nil error codes — handy for `codes.include?("THROTTLED")`.
+    sig { returns(T::Array[String]) }
     def codes
-      errors.map(&:code).compact
+      errors.filter_map(&:code)
     end
 
     # The machine side: every error with its path/code/extensions, plus
     # the drift verdict — nest this straight into a JSON response.
+    sig { override.returns(T::Hash[String, T.untyped]) }
     def to_h
       super.merge(
         "schema_stale" => schema_stale?,
@@ -276,6 +362,7 @@ module GraphWeaver
 
     private
 
+    sig { returns(String) }
     def summary
       first = errors.first
       more = errors.size > 1 ? " (and #{errors.size - 1} more)" : ""
@@ -291,30 +378,69 @@ module GraphWeaver
   # #cause carries the original TypeError/KeyError with the offending
   # prop in its message.
   class TypeError < Error
+    extend T::Sig
+
+    sig { returns(T.untyped) }
     attr_reader :struct
 
+    sig { params(struct: T.untyped, error: T.nilable(Exception), message: T.nilable(String)).void }
     def initialize(struct:, error: nil, message: nil)
       @struct = struct
       super("failed to cast response into #{struct}: #{message || error&.message}")
     end
 
+    sig { override.returns(T::Hash[String, T.untyped]) }
     def to_h
       super.merge("struct" => struct.to_s, "cause" => cause&.message)
     end
   end
 
+  # Raised when the variables passed to a query or mutation can't be built
+  # into the generated input structs — an unknown or typo'd input key, a
+  # missing required input field, an out-of-range enum, or a wrong-typed
+  # field. This is the "the caller's input was invalid" error: rescue it at
+  # an API boundary to return a 422. #field names the offending input field
+  # when known, #struct the input type being built; the underlying
+  # TypeError/KeyError/ArgumentError is preserved as #cause.
+  class InputError < Error
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :field
+
+    sig { returns(T.untyped) }
+    attr_reader :struct
+
+    sig { params(message: String, field: T.nilable(String), struct: T.untyped).void }
+    def initialize(message, field: nil, struct: nil)
+      @field = field
+      @struct = struct
+      super(message)
+    end
+
+    sig { override.returns(T::Hash[String, T.untyped]) }
+    def to_h
+      super.merge("field" => field, "struct" => struct&.to_s).compact
+    end
+  end
+
   # Build-time: the query didn't validate against the schema. Carries the
   # structured validation errors (message + line/column) rather than a
   # joined string. Under the Error umbrella like everything else raised
   # here (through 0.1.0 it was an ArgumentError instead).
   class ValidationError < Error
+    extend T::Sig
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
     attr_reader :errors
 
+    sig { params(errors: T::Array[T::Hash[Symbol, T.untyped]]).void }
     def initialize(errors)
       @errors = errors
       super("invalid query: #{errors.map { |e| e[:message] }.join("; ")}")
     end
 
+    sig { override.returns(T::Hash[String, T.untyped]) }
     def to_h
       super.merge("errors" => errors.map { |e| e.transform_keys(&:to_s) })
     end

data/lib/graph_weaver/hints.rb

@@ -3,6 +3,7 @@
 
 require "sorbet-runtime"
 
+require_relative "errors"
 require_relative "inflect"
 
 module GraphWeaver
@@ -32,7 +33,11 @@ module GraphWeaver
         end
         suggestion ? "#{key} (did you mean '#{suggestion}'?)" : key
       end
-      raise ArgumentError, "unknown key(s) for #{struct}: #{hints.join(", ")}"
+      raise GraphWeaver::InputError.new(
+        "unknown key(s) for #{struct}: #{hints.join(", ")}",
+        field: unknown.join(", "),
+        struct: struct,
+      )
     end
 
     def method_missing(name, *args, &block)

data/lib/graph_weaver/input_struct.rb

@@ -3,6 +3,7 @@
 
 require "sorbet-runtime"
 
+require_relative "errors"
 require_relative "hints"
 
 module GraphWeaver
@@ -53,6 +54,13 @@ module GraphWeaver
           raw = value.key?(field.prop) ? value[field.prop] : value[field.prop.to_s]
           [field.prop, raw.nil? || field.coercer.nil? ? raw : field.coercer.call(raw)]
         end)
+      rescue GraphWeaver::InputError
+        raise # already contextualized by a nested input / enum coercion
+      rescue ::TypeError, ::ArgumentError, KeyError => e
+        # a wrong-typed field, a missing required field, or an out-of-range
+        # enum — surface one branded, structured error for a 422. (`::` so the
+        # rescue catches Ruby's TypeError, not GraphWeaver::TypeError.)
+        raise GraphWeaver::InputError.new("invalid input for #{self}: #{e.message}", struct: self)
       end
     end
   end

data/lib/graph_weaver/response.rb

@@ -19,10 +19,10 @@ module GraphWeaver
 
     Data = type_member
 
-    sig { returns(T.nilable(Data)) }
+    sig { override.returns(T.nilable(Data)) }
     attr_reader :data
 
-    sig { returns(T::Array[GraphWeaver::GraphQLError]) }
+    sig { override.returns(T::Array[GraphWeaver::GraphQLError]) }
     attr_reader :errors
 
     sig { returns(T::Hash[String, T.untyped]) }

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/graph_weaver.rb

@@ -285,19 +285,19 @@ module GraphWeaver
     # GraphQL type — derived values live as methods next to the honest
     # wire data, and srb tc checks them against each query's selection:
     #
-    #      GraphWeaver.register_type("Pet", PetHelpers)
+    #      GraphWeaver.extend_type("Pet", PetHelpers)
     #
     # Or build the mixin inline with a block (module_eval'd into an
     # auto-named module — quick, but invisible to srb tc):
     #
-    #      GraphWeaver.register_type("Pet") do
+    #      GraphWeaver.extend_type("Pet") do
     #        def display_name = "#{name} the pet"
     #      end
     #
     # Additive (repeated and client-scoped registrations stack). Global;
-    # client.register_type scopes to one client.
-    def register_type(graphql_name, *mixins, requires: nil, &block)
-      Codegen.register_type(graphql_name, *mixins, requires:, &block)
+    # client.extend_type scopes to one client.
+    def extend_type(graphql_name, *mixins, requires: nil, &block)
+      Codegen.extend_type(graphql_name, *mixins, requires:, &block)
     end
 
     # Restore the built-in scalars, dropping every custom registration —

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Pepper
@@ -227,6 +227,7 @@ extra_rdoc_files: []
 files:
 - ".yardopts"
 - CHANGELOG.md
+- CLAUDE.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -236,6 +237,7 @@ files:
 - README.md
 - docs/cassettes.md
 - docs/errors.md
+- docs/federation.md
 - docs/generated_modules.md
 - docs/getting_started.md
 - docs/logging.md