graph_weaver 0.7.4 → 0.7.5

data/docs/scalars.md

@@ -428,7 +428,7 @@ It raises naming every scalar that disagreed and which way:
 ```
 2 scalar(s) disagree with Catalog::Schema:
   Money: the server refused "12.5", the wire form serialize: writes (expected "12.50 USD")
-  Decimal: round-trips lossily — sent 0.123456789123456789e9, got back 0.1234567891234567e9
+  Decimal: round-trips lossily — sent 123456789.123456789, got back 123456789.1234567
 ```
 
 The fabricated value is all it has to work with, so pin the one that matters:
@@ -505,13 +505,48 @@ Two safety properties do the real work:
 - **`fallback:` for forward-compat**: `fallback: PetKind::Unknown` makes *casting*
   absorb wire values the server added after you generated, so responses keep
   flowing instead of raising. Inputs stay strict either way: a typo'd input is your
-  bug, not drift. A union or interface absorbs the same drift with no registration
-  — a member added upstream lands in the catch-all `Other` its dispatch always
-  carries ([generated modules](generated_modules.md#abstract-types)).
+  bug, not drift. You don't need an enum of your own for that:
+  `GraphWeaver.register_enum("Species", fallback: true)` gives the *generated* enum
+  the same forward-compat, [below](#values-the-server-hasnt-told-you-about-yet).
 
 The translation tables are emitted into the generated source (`SPECIES_FROM_WIRE` /
 `SPECIES_TO_WIRE`) — reviewable in the diff, no runtime registry.
 
+### Values the server hasn't told you about yet
+
+A server adding an enum value is a deploy you weren't part of, and by default the
+next response carrying it raises. `fallback: true` says take it anyway:
+
+```ruby
+GraphWeaver.register_enum("Species", fallback: true)
+```
+
+The generated `Species` gains one member, `Other`, and every wire value the schema
+doesn't declare casts to it — the leniency a union or interface already has for
+free, where a member added upstream lands in the catch-all `Other` its dispatch
+always carries ([generated modules](generated_modules.md#abstract-types)).
+
+```ruby
+pet.species                    # => GraphQLTypes::Species::Other, for "AXOLOTL"
+```
+
+Three things follow from that, and they are the whole rule:
+
+- **`Other` doesn't carry the value it absorbed.** A `T::Enum` member is a
+  singleton, so there is nowhere to put it; the cast writes one debug line
+  (`GraphQLTypes::Species absorbed "AXOLOTL" into Other`) and that is the record
+  — so a presenter humanising the server's spelling can't, and falls back to a
+  label of its own.
+- **Inputs stay strict.** No wire value means `Other`, so a variable carrying it
+  is refused rather than sent. Everything else is unchanged: a typo'd input is
+  your bug, not drift.
+- **A schema that already declares `OTHER` keeps it.** The declared value stays
+  `Other`, and the fallback member is `Other2` — the same rule a union's
+  catch-all struct follows when a member is already named `Other`.
+
+It rides along with `alias:` on the one registration, and like every registration
+it belongs to one graph.
+
 ### Two spellings, one value
 
 A schema mid-rename declares both `LEGACY_MODE` and `legacy_mode` so old clients

data/docs/testing.md

@@ -423,7 +423,9 @@ time** — answering one means setting the client's context for the length of th
 dispatch, so the identity a request asked for is the identity it gets, whatever
 else is in flight. The lock is the client's own, so it holds however the endpoint
 is mounted. A `context:` hash is served **concurrently**: nothing writes it, so
-there is nothing to serialize.
+there is nothing to serialize. Either way a query reads its context once, so
+every subgraph it hops through runs as the identity it started with, even if
+the router's context is reassigned while it is in flight.
 
 ### Making the served endpoint fail
 

data/docs/upgrading.md

@@ -1,7 +1,8 @@
 # Upgrading
 
 [Regenerate](#regenerate-on-every-upgrade) whichever version you're on, then read
-the one section that is yours: from [0.7.3](#upgrading-from-073), from
+the one section that is yours: from [0.7.4](#upgrading-from-074), from
+[0.7.3](#upgrading-from-073), from
 [0.7.1](#upgrading-from-071), from [0.7.0](#upgrading-from-070) or from
 [0.6.1](#upgrading-from-061). Coming from 0.6.0 or older, the path is that
 version's own upgrade notes — read them at the tag they shipped under
@@ -23,6 +24,25 @@ That's the reminder working, not a false alarm. Generation is deterministic, so
 the diff is exactly what the new version emits differently and nothing else —
 worth reading rather than rubber-stamping.
 
+## Upgrading from 0.7.4
+
+Read the left column and skip what isn't yours; the
+[changelog](../CHANGELOG.md) says why each one moved.
+
+| applies if you… | what changed |
+|---|---|
+| spread a shared fragment as a whole field — `grep -rln '{ *\.\.\.[A-Za-z]* *}' app/graphql/queries` | on an object type it now [hoists](generated_modules.md#a-shared-fragment-is-one-type) into `GraphQLTypes` under the fragment's name, as it already did on a union. **App code naming the struct it used to produce (`PetQuery::Result::Pet`) moves to `GraphQLTypes::PetFields`** — one type instead of one per query, so a `T.type_alias { T.any(…) }` written to paper over that goes away. Regenerating and running `srb tc` finds every site |
+| register an `abstract!` mixin — `grep -rn 'extend_type' app config lib`, then check which of those modules call `abstract!` | **generation refuses** where a query doesn't select everything the mixin declares, instead of leaving it for your `srb tc`. The message names the struct, the members and the fixes: select them in that query, or select the type through one shared fragment so a single hoisted struct answers for every query |
+| keep a hand-maintained schema dump on a graph that also names a `client` — `rake graph_weaver:graphs` lists both per graph | `rake graph_weaver:schema:refresh` **rewrites that dump from the client** where it used to refuse and exit 1. If the file is the source of truth, don't run `refresh` for that graph, or drop the client from it |
+| call `Codegen#used_union_names` | it is `used_fragment_names` — the set it reports now includes hoisted object fragments |
+
+Then regenerate, and the gate:
+
+```sh
+rake graph_weaver:generate
+rake graph_weaver:verify
+```
+
 ## Upgrading from 0.7.3
 
 A patch release. One change can reach an app that never touched it — how a

data/lib/generators/graph_weaver/install_generator.rb

@@ -119,6 +119,28 @@ module GraphWeaver
         end
       end
 
+      # The same thing the header and the Exclude above say, told to GitHub:
+      # linguist-generated collapses these files in a diff ("Load diff") and
+      # drops them from the language breakdown. Display only — they stay
+      # versioned, expandable, and `git diff` here is untouched.
+      #
+      # Written even when there is no .gitattributes, unlike .rubocop.yml: a
+      # .gitattributes turns no tooling on, so there is no app this surprises.
+      def mark_generated_for_github
+        body = File.read(gitattributes) if File.exist?(gitattributes)
+        # already marked — a re-run, or done by hand
+        globs = linguist_globs.reject { |glob| body&.include?(glob) }
+        return if globs.empty?
+
+        lines = globs.map { |glob| "#{glob} linguist-generated" }.join("\n")
+        marks = <<~TEXT + lines + "\n"
+          # Machine-written by `rake graph_weaver:generate` — GitHub collapses it in
+          # diffs and leaves it out of the language breakdown.
+        TEXT
+
+        body ? append_to_file(GITATTRIBUTES, "\n#{marks}") : create_file(GITATTRIBUTES, marks)
+      end
+
       # The `graphql:` tags need this require, and it has to be somewhere
       # rspec actually loads. A spec/support file is not: rspec-rails ships
       # the spec/support glob commented out, so the require sat there doing
@@ -191,6 +213,7 @@ module GraphWeaver
       private
 
       RUBOCOP_CONFIG = ".rubocop.yml"
+      GITATTRIBUTES = ".gitattributes"
 
       # rails_helper first: rspec-rails writes both, and only rails_helper
       # has Rails booted by the time the require runs.
@@ -203,6 +226,8 @@ module GraphWeaver
 
       def rubocop_config = File.join(GraphWeaver.root, RUBOCOP_CONFIG)
 
+      def gitattributes = File.join(GraphWeaver.root, GITATTRIBUTES)
+
       # Parsed, not counted: a `---` can also be a line inside a block scalar.
       # A file rubocop itself can't read is left to rubocop to complain about.
       def yaml_documents(body)
@@ -213,9 +238,13 @@ module GraphWeaver
 
       # Every graph's output directory, so a multi-schema app is covered by
       # the same run — read off the graphs rather than restated here.
-      def generated_globs
-        GraphWeaver.graphs.map { |graph| File.join(graph.output, "**/*") }.uniq
-      end
+      def generated_outputs = GraphWeaver.graphs.map(&:output).uniq
+
+      def generated_globs = generated_outputs.map { |dir| File.join(dir, "**/*") }
+
+      # gitattributes patterns are gitignore-style, where `dir/**` is
+      # everything beneath dir — spelled as git reads it, not as rubocop does.
+      def linguist_globs = generated_outputs.map { |dir| File.join(dir, "**") }
 
       # This install run is the one moment the user is guaranteed to be
       # reading, and a composed supergraph changes what the next steps are:

data/lib/graph_weaver/codegen/aliases.rb

@@ -119,6 +119,7 @@ class GraphWeaver::Codegen
           nilable = true
         else
           obj = object_of(cur)
+          refuse_hoisted!(node, name, hoisted_of(cur), seg)
           unless obj
             hint = if list_of(cur)
               " — use .first or .last to pick an element"
@@ -155,6 +156,19 @@ class GraphWeaver::Codegen
       ObjectNode::Alias.new(name, expr, type)
     end
 
+    # A hop landing on a hoisted shared fragment: the struct is another
+    # module's, so the path stops here. Which query hoists is a property of how
+    # that query spreads the fragment, so optional: still skips it.
+    def refuse_hoisted!(node, name, ref, seg)
+      return unless ref
+
+      raise GraphWeaver::Error,
+        "alias #{name.inspect} on #{node.graphql_type}: '#{seg}' is inside the shared fragment " \
+        "#{ref.class_name}, which hoists to #{@types_namespace}::#{ref.class_name} — a path can't " \
+        "read into it. Register the alias on #{ref.graphql_type}, or select a field beside the " \
+        "spread to keep the struct local"
+    end
+
     # Separate "this query didn't select it" from "no query could": a segment
     # the schema doesn't declare on the type is a mistake in the registration,
     # so it raises even for an optional alias — which otherwise turns a typo
@@ -185,7 +199,7 @@ class GraphWeaver::Codegen
     # The leaf's Sorbet type as referenced from the aliased struct. Generated
     # nested constants (structs, enums, unions) must carry the container path,
     # since the delegator's `sig` is emitted in an outer struct where a bare
-    # `Sub` wouldn't resolve; scalars, mapped enums, and hoisted union refs are
+    # `Sub` wouldn't resolve; scalars, mapped enums, and hoisted refs are
     # already top-level. `containers` is the class-name chain to the leaf.
     def qualified_alias_type(node, containers)
       node = node.of if node.is_a?(NonNull)
@@ -203,10 +217,17 @@ class GraphWeaver::Codegen
       # there from the shared enums module — either way, no container prefix
       when EnumNode then node.class_name
       when UnionNode then "#{prefix}#{node.bare_type}"
-      else node.bare_type # Scalar, MappedEnum, UnionRefNode — already top-level
+      else node.bare_type # Scalar, MappedEnum, a hoisted ref — already top-level
       end
     end
 
+    # the hoisted-fragment reference a node resolves to (through NON_NULL), or nil
+    def hoisted_of(node)
+      node = T.let(node, T.untyped)
+      node = node.of while node.is_a?(NonNull)
+      node if node.is_a?(HoistedRefNode)
+    end
+
     # the List a node wraps (through NON_NULL), or nil
     def list_of(node)
       node = T.let(node, T.untyped)

data/lib/graph_weaver/codegen/emit.rb

@@ -130,8 +130,8 @@ class GraphWeaver::Codegen
     # The shared types artifact as files: one file per type under types/, plus
     # types.rb — the manifest that requires them in the order the runtime needs
     # (see below). One rule for all three kinds, so a schema migration diffs
-    # exactly the types it touched whether they're inputs, enums or unions.
-    def emit_types_files(unions)
+    # exactly the types it touched whether they're inputs, enums or fragments.
+    def emit_types_files(fragments)
       files = {}
       # a mapped enum's constants are its wire tables, but the file is still
       # named for the GraphQL enum — one type, one file, whichever it is
@@ -142,15 +142,15 @@ class GraphWeaver::Codegen
       }
       inputs, = ordered_inputs
       structs = inputs.map { |input| type_file(files, input.class_name) { |out| emit_input(input, out, 1) } }
-      hoisted = unions.map { |union| type_file(files, union.class_name) { |out| emit_union(union, out, 1) } }
+      hoisted = fragments.map { |node| type_file(files, node.class_name) { |out| emit_nested(node, out, 1) } }
 
       out = []
       out << "# typed: strict"
       out << "# frozen_string_literal: true"
       out << ""
       out << "# Generated by GraphWeaver #{GraphWeaver::VERSION} — do not edit. Shared types for this schema —"
-      out << "# input types, enums, and unions hoisted from shared fragments — one file"
-      out << "# per type; query modules alias what they use."
+      out << "# input types, enums, and the types hoisted out of shared fragments — one"
+      out << "# file per type; query modules alias what they use."
       out << ""
       requires = @requires.uniq.sort
       if requires.any?
@@ -175,7 +175,7 @@ class GraphWeaver::Codegen
       # both spell them bare, and a T::Enum can't be forward-declared the way
       # an input struct can
       if enums.any? && (structs.any? || hoisted.any?)
-        out << "# enums first — input structs and union members spell them bare"
+        out << "# enums first — input structs and hoisted fragments spell them bare"
       end
       (enums.sort + structs.sort + hoisted.sort).each do |file|
         out << "require_relative #{file.delete_suffix(".rb").inspect}"
@@ -210,11 +210,11 @@ class GraphWeaver::Codegen
     # assembled from the generator's walked state.
     def emit_module(root, variables, representations = [], operation_name = nil)
       # Every shared type this module names: its variable root inputs, the
-      # enums it reached, and the unions it hoisted (aliased so <Name>::Type
-      # and <Name>.from_h resolve to the shared module).
+      # enums it reached, and the fragments it hoisted (aliased so <Name> and
+      # <Name>.from_h resolve to the shared module).
       aliases = if @types_namespace
         (shared_input_names(variables) + shared_enum_names +
-          @used_unions.map { |name| camelize(name) }).uniq.sort
+          @used_fragments.map { |name| camelize(name) }).uniq.sort
       else
         []
       end
@@ -338,6 +338,10 @@ class GraphWeaver::Codegen
       node.values.each do |value|
         out << "#{pad}    #{camelize(value.downcase)} = new(#{value.inspect})"
       end
+      if node.fallback?
+        out << "#{pad}    # every other wire value casts here (register_enum fallback: true)"
+        out << "#{pad}    #{node.fallback} = new(#{GraphWeaver::Internal::ENUM_FALLBACK_WIRE.inspect})"
+      end
       out << "#{pad}  end"
       out << "#{pad}end"
       return unless node.aliased?

data/lib/graph_weaver/codegen/enum_type.rb

@@ -22,6 +22,10 @@ class GraphWeaver::Codegen
   # value — both spellings cast, the target is what serializes. It is the
   # whole registration when there is no T::Enum to map onto, and then the
   # generated enum gets one constant for the target and none for the alias.
+  #
+  # fallback: true is the same type-less form asking for leniency instead:
+  # the generated enum gains an Other member and absorbs undeclared wire
+  # values into it (see Codegen#enum_values).
   class EnumType
     attr_reader :graphql_name, :type, :fallback, :requires
 
@@ -55,6 +59,10 @@ class GraphWeaver::Codegen
       end
     end
 
+    # register_enum("Species", fallback: true): the generated enum gains an
+    # Other member and casts every undeclared wire value to it.
+    def generated_fallback? = type.nil? && fallback == true
+
     # The wire tables for a mapped enum: [wire value => member, member => the
     # wire value that goes out]. Every spelling casts; an alias's target is the
     # one that serializes.
@@ -115,19 +123,27 @@ class GraphWeaver::Codegen
 
     private
 
-    # Without a T::Enum there is nothing for map:/fallback:/requires: to
-    # describe, so alias: is the whole registration.
+    # Without a T::Enum there is nothing for map:/requires: to describe, so
+    # alias: and fallback: true are the whole registration.
     def alias_only!(map, fallback, requires)
-      if @aliases.empty?
+      if fallback && fallback != true
+        raise ArgumentError, "register_enum(#{graphql_name.inspect}, fallback: #{fallback.inspect}): the " \
+          "generated enum generates its fallback member too, so say fallback: true. To fall back onto a " \
+          "member of your own, pass the T::Enum: " \
+          "register_enum(#{graphql_name.inspect}, YourEnum, fallback: YourEnum::Unknown)"
+      end
+
+      if @aliases.empty? && !fallback
         raise ArgumentError, "register_enum(#{graphql_name.inspect}) says nothing about #{graphql_name} — " \
-          "pass the T::Enum to map it onto, or alias: { \"old\" => \"NEW\" } to read two wire values as one"
+          "pass the T::Enum to map it onto, alias: { \"old\" => \"NEW\" } to read two wire values as one, " \
+          "or fallback: true to absorb values the server adds"
       end
 
-      extra = { map:, fallback:, requires: }.compact.keys.first
+      extra = { map:, requires: }.compact.keys.first
       if extra
         raise ArgumentError,
-          "register_enum(#{graphql_name.inspect}, alias: {...}) takes no #{extra}: — that describes a T::Enum " \
-          "of your own, so pass one: register_enum(#{graphql_name.inspect}, YourEnum, alias: {...})"
+          "register_enum(#{graphql_name.inspect}) takes no #{extra}: — that describes a T::Enum of your own, " \
+          "so pass one: register_enum(#{graphql_name.inspect}, YourEnum, #{extra}: {...})"
       end
 
       @requires = []
@@ -189,8 +205,9 @@ class GraphWeaver::Codegen
 
   # The enum half of one graph's registrations — see Codegen::Registry.
   class Registry
-    # Map a GraphQL enum onto an app-owned T::Enum, or fold two of its wire
-    # spellings into one value (see EnumType). The one implementation —
+    # Map a GraphQL enum onto an app-owned T::Enum, fold two of its wire
+    # spellings into one value, or absorb the ones the server hasn't told you
+    # about yet (see EnumType). The one implementation —
     # GraphWeaver.register_enum is a delegate, so the same call reaches it
     # whichever door you came in by.
     #

data/lib/graph_weaver/codegen/nodes.rb

@@ -113,11 +113,11 @@ class GraphWeaver::Codegen
 
     def cast(expr, depth)
       var = "v#{depth}"
-      element = if @of.non_null? || @of.identity?
-        @of.identity? ? var : @of.cast(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.cast("v#{depth + 1}", depth + 2)} }"
-      end
+      element =
+        if @of.identity? then var
+        elsif @of.non_null? then @of.cast(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.cast("v#{depth + 1}", depth + 2)} }"
+        end
 
       "#{expr}.map { |#{var}| #{element} }"
     end
@@ -127,11 +127,11 @@ class GraphWeaver::Codegen
 
     def serialize(expr, depth)
       var = "v#{depth}"
-      element = if @of.non_null? || @of.serialize_identity?
-        @of.serialize_identity? ? var : @of.serialize(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.serialize("v#{depth + 1}", depth + 2)} }"
-      end
+      element =
+        if @of.serialize_identity? then var
+        elsif @of.non_null? then @of.serialize(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.serialize("v#{depth + 1}", depth + 2)} }"
+        end
 
       "#{expr}.map { |#{var}| #{element} }"
     end
@@ -153,11 +153,11 @@ class GraphWeaver::Codegen
 
     def hash_coerce(expr, depth)
       var = "v#{depth}"
-      inner = if @of.non_null? || @of.hash_coerce_identity?
-        @of.hash_coerce_identity? ? var : @of.hash_coerce(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.hash_coerce("v#{depth + 1}", depth + 2)} }"
-      end
+      inner =
+        if @of.hash_coerce_identity? then var
+        elsif @of.non_null? then @of.hash_coerce(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.hash_coerce("v#{depth + 1}", depth + 2)} }"
+        end
       return "#{expr}.map { |#{var}| #{inner} }" if hash_coerce_identity?
 
       # the index is a path segment — `where._and.0._not.species` needs the 0
@@ -207,10 +207,13 @@ class GraphWeaver::Codegen
   class EnumNode < Node
     attr_reader :class_name, :values, :aliases
 
-    def initialize(class_name, values, aliases = {})
+    # fallback: the name of the member unknown wire values cast to (register_enum
+    # fallback: true), or nil for a strict enum
+    def initialize(class_name, values, aliases = {}, fallback: nil)
       @class_name = class_name
       @values = values
       @aliases = aliases
+      @fallback = fallback
     end
 
     def bare_type = class_name
@@ -220,10 +223,19 @@ class GraphWeaver::Codegen
     def aliased? = !@aliases.empty?
     def alias_const = "#{GraphWeaver::Inflect.underscore(class_name).upcase}_ALIASES"
 
+    # register_enum fallback: true — the extra member every value the schema
+    # doesn't declare casts to, and the one member a variable can't send
+    attr_reader :fallback
+    def fallback? = !@fallback.nil?
+    def fallback_const = "#{class_name}::#{@fallback}"
+
     def cast(expr, _depth)
-      "GraphWeaver::Hints.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
+      "GraphWeaver::Hints.enum(#{class_name}, #{expr}#{runtime_args})"
     end
 
+    # Other serializes to ENUM_FALLBACK_WIRE, which casts back to Other — so a
+    # result carrying it still round-trips through #as_json, even though no
+    # server would accept that spelling.
     def serialize(expr, _depth)
       "#{expr}.serialize"
     end
@@ -235,7 +247,11 @@ class GraphWeaver::Codegen
     def coerce? = true
 
     def coerce(expr)
-      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
+      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr}#{runtime_args})"
+    end
+
+    def runtime_args
+      "#{", #{alias_const}" if aliased?}#{", fallback: #{fallback_const}" if fallback?}"
     end
 
     def input_type = "T.any(#{class_name}, String)"
@@ -358,20 +374,22 @@ class GraphWeaver::Codegen
     def nested = self
   end
 
-  # A reference to a union hoisted into the shared types module (a named
-  # shared fragment spread as a whole union field): the query references
-  # <Name>::Type and dispatches through <Name>.from_h, where <Name> is the
-  # alias the query module gives GraphQLTypes::<Name>. The type family lives
-  # once in the shared module, so the same union across queries is one Ruby
-  # type — nested is nil, nothing is emitted here.
-  class UnionRefNode < Node
-    attr_reader :class_name
-
-    def initialize(class_name)
+  # A reference to a type hoisted into the shared types module (a named shared
+  # fragment spread as a whole field): the query casts through <Name>.from_h,
+  # where <Name> is the alias the query module gives GraphQLTypes::<Name>. The
+  # type lives once in the shared module, so the same fragment across queries
+  # is one Ruby type — nested is nil, nothing is emitted here.
+  class HoistedRefNode < Node
+    # graphql_type is carried for refusals alone — an alias path that tries to
+    # read into the hoisted struct says which type to register itself on
+    attr_reader :class_name, :graphql_type
+
+    def initialize(class_name, graphql_type = nil)
       @class_name = class_name
+      @graphql_type = graphql_type
     end
 
-    def bare_type = "#{class_name}::Type"
+    def bare_type = class_name
 
     def cast(expr, _depth)
       "#{class_name}.from_h(#{expr})"
@@ -382,6 +400,12 @@ class GraphWeaver::Codegen
     end
   end
 
+  # The same, on an abstract type: the hoisted name is a dispatch module, so
+  # the Ruby type is its member union rather than the module itself.
+  class UnionRefNode < HoistedRefNode
+    def bare_type = "#{class_name}::Type"
+  end
+
   # An input-object variable: emitted as a module-level T::Struct whose
   # serialize produces the wire hash. Inputs never cast FROM the wire.
   # Joins the coerce protocol so execute kwargs accept plain hashes,
@@ -454,6 +478,6 @@ class GraphWeaver::Codegen
   # The IR is codegen's own vocabulary — every node type is reachable only
   # from inside the walk.
   private_constant :Node, :Scalar, :NonNull, :List, :ObjectNode, :EnumNode,
-    :MappedEnum, :NarrowedNode, :UnionNode, :UnionRefNode, :InputNode,
-    :RepresentationNode
+    :MappedEnum, :NarrowedNode, :UnionNode, :HoistedRefNode, :UnionRefNode,
+    :InputNode, :RepresentationNode
 end