graph_weaver 0.7.2 → 0.7.4

data/lib/graph_weaver/railtie.rb

@@ -7,16 +7,25 @@
 #   rake_tasks block, so graph_weaver:* tasks appear with no Rakefile
 #   edit. (Outside Rails there is no task-discovery hook — add
 #   `require "graph_weaver/tasks"` to your Rakefile.)
-# - generated modules: required at boot once every registration has run —
-#   both the initializer kind and the to_prepare kind, since a generated
-#   file `include`s the type helper it was generated with and that
-#   constant must resolve. load_generated! stays idempotent, so calling
-#   it yourself too is harmless.
+# - generated modules: required once every registration has run — both the
+#   initializer kind and the to_prepare kind, since a generated file
+#   `include`s the type helper it was generated with and that constant must
+#   resolve. load_generated! stays idempotent, so calling it yourself too is
+#   harmless.
 # - Zeitwerk: the generated directory is hidden from it, since the
 #   default one lives under app/ and its files define top-level
 #   constants.
 # - watch mode: in development, editing a .graphql regenerates before the
 #   next request, the way editing a route or a locale takes effect.
+#
+# All of that is hung off Rails' lifecycle HOOKS — before_initialize,
+# after_initialize, the reloader — rather than off initializers with
+# `after:`/`before:` edges naming other railties' initializers. Rails
+# topologically sorts every railtie's initializers together, so such an edge
+# constrains the whole app's boot order and tsort is free to satisfy it by
+# moving initializers that aren't ours: a real app failed to boot with
+# graph_weaver in the Gemfile and every one of these bodies neutered. A hook
+# has a fixed place in boot and adds no edge. See DECISIONS.md.
 class GraphWeaver::Railtie < Rails::Railtie
   # config.graph_weaver.watch — false to never regenerate during a request.
   # Default: development only. Every other setting is a top-level one, and an
@@ -62,94 +71,87 @@ class GraphWeaver::Railtie < Rails::Railtie
   config.graph_weaver = Options.new
 
   class << self
-    # The file watcher, so the to_prepare block below can ask it whether a
-    # query changed. nil when not watching.
+    # The file watcher, so the prepare hook below can ask it whether a query
+    # changed. nil when not watching.
     attr_accessor :watcher
 
-    # What ignore_generated actually hid, resolved. Zeitwerk only reads its
+    # What has been hidden from Zeitwerk, resolved. Zeitwerk only reads its
     # ignore list at setup, so anything that arrives later isn't hidden by
     # calling ignore again — check_generated_ignored! refuses instead.
     attr_accessor :ignored_dirs
+
+    # Whether hiding an output right now would actually hide it: false until
+    # the initializer below has swept (it picks up anything declared so far),
+    # and false again from the moment Zeitwerk sets the main autoloader up.
+    attr_accessor :hiding_outputs
   end
 
   rake_tasks do
     require "graph_weaver/tasks"
   end
 
-  # The two auto-wires an app gets for free, and the only two it can turn off
-  # by assigning nil. They are declared FIRST, and `before:
-  # :load_config_initializers`, and both of those are load-bearing:
+  # ONE initializer, and it declares no `after:` — see the note on the class.
+  # The `before:` that is left is inert: it only says "not after Zeitwerk's
+  # setup", and this is emitted at its own place in the railties block anyway,
+  # so nothing moves. It records the deadline.
   #
-  # Rails gives an initializer an implicit `after:` of the previous one in the
-  # same railtie (Initializable#initializer: `opts[:after] ||=
-  # initializers.last&.name`). Declared after ignore_generated, which is
-  # `after: :load_config_initializers`, these two inherited that position —
-  # they ran AFTER config/initializers, so the `if nil?` fallback overwrote an
-  # app that had just said nil and the documented PII opt-out did nothing,
-  # silently, while queries and variables kept reaching a debug Rails.logger.
-  # Adding the `before:` without moving them is a TSort::Cyclic at boot, since
-  # the implicit `after:` would then point through ignore_generated.
-  #
-  # Rails.logger, unless the app already chose one (set
-  # GraphWeaver.logger = nil in an initializer to silence)
-  initializer "graph_weaver.logger", before: :load_config_initializers do
-    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  # What it sweeps is what config/application.rb configured. A graph declared
+  # in config/initializers is later than this and hides its own output as it is
+  # declared (ignore_output!) — which is where that knowledge arrives, and so
+  # needs no edge to wait for.
+  initializer "graph_weaver.ignore_generated", before: :setup_main_autoloader do
+    GraphWeaver::Railtie.hide_generated!
   end
 
-  # An APM sees every GraphQL call without the app configuring anything:
-  # the ActiveSupport::Notifications adapter from docs/logging.md, plus the
-  # LogSubscriber that turns its event into one line. Measured at ~4.5µs per
-  # execution all told (0.13µs of that ActiveSupport::Notifications itself
-  # with nothing subscribed; the rest is its Event machinery) — 0.05% of a
-  # 10ms round trip, so there is nothing to weigh.
-  #
-  # An instrumenter the app set is never replaced: assigned before this (in
-  # config/application.rb) the nil check leaves it, and config/initializers now
-  # genuinely runs later, so one assigned there wins on its own — including
-  # `GraphWeaver.instrumenter = nil` to opt out.
-  initializer "graph_weaver.instrumentation", before: :load_config_initializers do
-    next unless defined?(ActiveSupport::Notifications)
-
-    if GraphWeaver.instrumenter.nil?
-      GraphWeaver.instrumenter = lambda do |event, payload, &block|
-        ActiveSupport::Notifications.instrument(event, payload, &block)
-      end
+  # generated/person_query.rb defines ::PersonQuery, but Zeitwerk infers
+  # Generated::PersonQuery from the path — and app/graphql/generated is inside
+  # an autoload root by default, so eager loading raised "uninitialized
+  # constant Generated::PersonQuery" in production while development (lazy) was
+  # fine. prepare_generated! requires them instead.
+  def self.hide_generated!
+    self.ignored_dirs = []
+    self.hiding_outputs = true
+    GraphWeaver::Internal::Util.generated_dirs.each { |path| ignore_output!(path) }
+
+    # Zeitwerk reads its ignore list once, at setup, and nothing in Rails
+    # announces that moment — Zeitwerk itself does. With no such signal, shut
+    # the window here: an ignore registered after setup hides nothing, and
+    # check_generated_ignored! has to be the one to say so.
+    main = Rails.autoloaders.main if Rails.autoloaders.respond_to?(:main)
+    if main.respond_to?(:on_setup)
+      main.on_setup { GraphWeaver::Railtie.hiding_outputs = false }
+    else
+      self.hiding_outputs = false
     end
-
-    # ActiveSupport::LogSubscriber is one of ActiveSupport's own eager
-    # autoloads, so naming it is enough — no require of theirs needed
-    require "graph_weaver/log_subscriber"
-    # idempotent — Subscriber.add_event_subscriber skips a pattern it already has
-    GraphWeaver::LogSubscriber.attach_to :graph_weaver
   end
 
-  # generated/person_query.rb defines ::PersonQuery, but Zeitwerk infers
-  # Generated::PersonQuery from the path — and app/graphql/generated is
-  # inside an autoload root by default, so eager loading raised
-  # "uninitialized constant Generated::PersonQuery" in production while
-  # development (lazy) was fine. load_generated! below requires them.
+  # Hide one output from Zeitwerk, the moment it is named — a graph declared in
+  # config/initializers says where it writes long after the sweep above ran.
+  # Waiting for it instead is what `after: :load_config_initializers` used to
+  # buy, at the cost of the whole app's boot order.
   #
-  # after: :load_config_initializers as well as before Zeitwerk's setup — a
-  # graph's output: is only known once the app has declared its graphs, and
-  # with only the `before:` constraint this ran ~20 initializers too early, so
-  # an output outside the conventional glob was eager loaded on top of
-  # load_generated! and died on a redefined enum.
-  initializer "graph_weaver.ignore_generated",
-    after: :load_config_initializers, before: :setup_main_autoloader do
-    # patterns, not paths — generated_paths may be globs, and Zeitwerk
-    # expands its own at setup (which is what this runs before)
-    dirs = GraphWeaver::Internal::Util.generated_dirs.map { GraphWeaver::Railtie.autoload_path(_1) }
-    GraphWeaver::Railtie.check_autoload_once!(dirs)
-    GraphWeaver::Railtie.ignored_dirs = dirs
-    Rails.autoloaders.each { |loader| dirs.each { |path| loader.ignore(path) } }
+  # Outside the window this is a no-op on purpose: before it, the sweep will
+  # pick the path up; after it, calling Zeitwerk's `ignore` would only teach
+  # check_generated_ignored! a lie.
+  def self.ignore_output!(path)
+    return unless hiding_outputs
+
+    # patterns, not paths — generated_paths may be globs, and Zeitwerk expands
+    # its own at setup, which is what the window stays open until
+    dir = autoload_path(path)
+    return if ignored_dirs.include?(dir)
+
+    check_autoload_once!([dir])
+    ignored_dirs << dir
+    Rails.autoloaders.each { |loader| loader.ignore(dir) }
   end
 
-  # The `once` autoloader is set up in bootstrap, and Zeitwerk reads its ignore
-  # list only at setup — so the `loader.ignore` above, which runs after
-  # config/initializers, hides nothing from it however the output is spelled.
-  # The generic advice ("name it in GraphWeaver.generated_paths from
-  # config/initializers") produced byte-identical output for this one, so it
-  # gets its own refusal, naming the place that is still early enough.
+  # The `once` autoloader is set up in bootstrap, before any of this — and
+  # Zeitwerk reads its ignore list only at setup, so `loader.ignore` hides
+  # nothing from it however the output is spelled. The generic advice ("name it
+  # in GraphWeaver.generated_paths from config/initializers") produced
+  # byte-identical output for this one, so it gets its own refusal, naming the
+  # place that is still early enough.
   def self.check_autoload_once!(dirs)
     return unless Rails.respond_to?(:autoloaders) && Rails.autoloaders.respond_to?(:once)
 
@@ -232,13 +234,64 @@ class GraphWeaver::Railtie < Rails::Railtie
     end
   end
 
+  # The two auto-wires an app gets for free, and the only two it can turn off
+  # by assigning nil.
+  #
+  # before_initialize runs in Rails' own :bootstrap_hook — after
+  # :initialize_logger and before the first railtie initializer, so the default
+  # is in place for anything that boots, and config/initializers still runs
+  # later and still wins. That timing used to be a `before:
+  # :load_config_initializers` edge, and getting it wrong shipped: declared
+  # without one, these ran AFTER config/initializers, so the `if nil?` fallback
+  # overwrote an app that had just said nil — the documented PII opt-out did
+  # nothing, silently, while queries and variables kept reaching a debug
+  # Rails.logger.
+  config.before_initialize { GraphWeaver::Railtie.default_logger! }
+
+  # Rails.logger, unless the app already chose one (set GraphWeaver.logger =
+  # nil in an initializer to silence)
+  def self.default_logger!
+    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  end
+
+  # An APM sees every GraphQL call without the app configuring anything:
+  # the ActiveSupport::Notifications adapter from docs/logging.md, plus the
+  # LogSubscriber that turns its event into one line. Measured at ~4.5µs per
+  # execution all told (0.13µs of that ActiveSupport::Notifications itself
+  # with nothing subscribed; the rest is its Event machinery) — 0.05% of a
+  # 10ms round trip, so there is nothing to weigh.
+  #
+  # An instrumenter the app set is never replaced: assigned before this (in
+  # config/application.rb) the nil check leaves it, and config/initializers runs
+  # later, so one assigned there wins on its own — including
+  # `GraphWeaver.instrumenter = nil` to opt out.
+  config.before_initialize { GraphWeaver::Railtie.default_instrumenter! }
+
+  def self.default_instrumenter!
+    return unless defined?(ActiveSupport::Notifications)
+
+    if GraphWeaver.instrumenter.nil?
+      GraphWeaver.instrumenter = lambda do |event, payload, &block|
+        ActiveSupport::Notifications.instrument(event, payload, &block)
+      end
+    end
+
+    # ActiveSupport::LogSubscriber is one of ActiveSupport's own eager
+    # autoloads, so naming it is enough — no require of theirs needed
+    require "graph_weaver/log_subscriber"
+    # idempotent — Subscriber.add_event_subscriber skips a pattern it already has
+    GraphWeaver::LogSubscriber.attach_to :graph_weaver
+  end
+
   # The app already declared what is sensitive, so variables logged at debug
   # honour the same list as its request logs — including the Procs and dotted
-  # paths only ParameterFilter understands. after: :load_config_initializers,
-  # since filter_parameter_logging.rb is where an app adds to it.
-  initializer "graph_weaver.filter_parameters", after: :load_config_initializers do |app|
+  # paths only ParameterFilter understands. after_initialize, since
+  # filter_parameter_logging.rb is where an app adds to it.
+  config.after_initialize { |app| GraphWeaver::Railtie.adopt_filter_parameters!(app) }
+
+  def self.adopt_filter_parameters!(app)
     filters = app.config.filter_parameters
-    next if filters.empty? || GraphWeaver.filter_parameters != GraphWeaver::DEFAULT_FILTER_PARAMETERS
+    return if filters.empty? || GraphWeaver.filter_parameters != GraphWeaver::DEFAULT_FILTER_PARAMETERS
 
     GraphWeaver.filter_parameters = ActiveSupport::ParameterFilter.new(filters)
   end
@@ -246,41 +299,31 @@ class GraphWeaver::Railtie < Rails::Railtie
   # Watch mode. A .graphql edit should reach the next request the way a route
   # or a locale change does, so the query directories and the schema dump
   # become one of Rails' own reloaders: a change there alone triggers a reload
-  # cycle, and the to_prepare below regenerates before it loads. Off with
+  # cycle, and the prepare hook below regenerates before it loads. Off with
   #
   #      config.graph_weaver.watch = false
   #
-  # after: :load_config_initializers — that's where an app moves
-  # queries_paths, and the finisher that reads app.reloaders runs later still.
-  #
-  # to_prepare, not the initializer itself: a graph declared from one of those
-  # (what the docs say to do when its block names an autoloaded constant) isn't
-  # declared until every initializer has run, and a watcher built before it
-  # watched the default queries_paths — an edit to that graph's .graphql
-  # silently never regenerated. to_prepare blocks run in registration order and
-  # an app registers its own during :load_config_initializers, which this is
-  # `after:`, so every graph is in by the time this runs; app.reloaders is read
-  # per request, so joining it this late still counts. Once, though: a dev
-  # reload re-runs to_prepare, and a second watcher is a second reloader over
-  # the same files.
-  initializer "graph_weaver.watch", after: :load_config_initializers do |app|
-    watched = false
-    app.config.to_prepare do
-      next if watched
-
-      watched = true
-      GraphWeaver::Railtie.watch!(app)
-    end
-  end
+  # after_initialize, because every graph has to be declared before the watcher
+  # is built: a graph declared from a to_prepare block (what the docs say to do
+  # when its block names an autoloaded constant) isn't declared until the
+  # prepare callbacks have run, and a watcher built before it watched the
+  # default queries_paths — an edit to that graph's .graphql silently never
+  # regenerated. app.reloaders is read per request, so joining it this late
+  # still counts.
+  config.after_initialize { |app| GraphWeaver::Railtie.watch!(app) }
 
   # Registers the watcher, and says so: this is the one thing GraphWeaver does
   # that writes a checked-in file outside a rake task. Returns it, or nil when
   # nothing is being watched.
   def self.watch!(app)
+    # exactly one watcher per app, however many times this is called — a second
+    # one is a second reloader polling the same files
+    app.reloaders.delete(watcher) if watcher
+
     watch = app.config.graph_weaver.watch
     watch = Rails.env.development? if watch.nil?
-    # with reloading off nothing re-runs to_prepare, so a watcher could only
-    # promise something it can't do
+    # with reloading off nothing re-runs the prepare hook, so a watcher could
+    # only promise something it can't do
     return self.watcher = nil unless watch && app.config.reloading_enabled?
 
     # a directory that doesn't exist yet is still watched — FileUpdateChecker
@@ -321,51 +364,63 @@ class GraphWeaver::Railtie < Rails::Railtie
   end
 
   # A generated file `include`s the type helper it was generated with, so it
-  # can't load until that constant resolves — and both Zeitwerk's setup and
-  # the app's own to_prepare blocks (where extend_type/register_enum are told
-  # to register, Codegen::AUTOLOAD_HINT) happen after config/initializers.
-  # to_prepare, not `after:` a finisher initializer: naming one there makes
-  # tsort hoist it ahead of the app's own config/initializers. Re-running on
-  # each dev reload is free — require is idempotent — and picks up a module
-  # generated since boot.
-  initializer "graph_weaver.load_generated", after: :load_config_initializers do |app|
-    app.config.to_prepare do
-      # The graph_weaver tasks write these files and need none of them loaded.
-      # Loading them would let a stale one block its own repair: a dropped
-      # extend_type leaves a dangling include, and generate depends on
-      # :environment, so boot failed before the task that would regenerate it.
-      next if GraphWeaver.skip_generated_load
-
-      # the app's own to_prepare blocks have run by now, so this is the first
-      # point that sees every graph — and the last before one of them loads
-      GraphWeaver::Railtie.check_generated_ignored!
-
-      # Regenerate first, then load — and here rather than in the watcher's own
-      # to_run, so an extend_type or register_enum the app registers in its own
-      # to_prepare is already in place (that block was registered at
-      # :load_config_initializers, so it has run by now). A run that
-      # regenerated has already reloaded what it wrote.
-      next if GraphWeaver::Railtie.watcher&.execute_if_updated
-
-      # entries may be globs, so Dir[] rather than Dir.exist?
-      generated = GraphWeaver::Internal::Util.generated_dirs.any? do |dir|
-        Dir[GraphWeaver::Internal::Util.resolve(dir)].any?
-      end
-      next unless generated
-
-      # `require` no-ops on a file it has already read — which is what we want,
-      # except when the constant that file defined is gone. A graph's
-      # `namespace:` is normally a module Zeitwerk owns (app/graphql/accounts/
-      # implies Accounts), and unloading it on a dev reload takes the generated
-      # module nested inside it with it; require then restores nothing and every
-      # request 500s on "uninitialized constant Accounts::PersonQuery" until a
-      # .graphql edit happens to trigger the watcher. An un-namespaced module
-      # defines a top-level constant Zeitwerk never manages, so it survives.
-      if GraphWeaver.graphs.any?(&:namespace)
-        GraphWeaver.reload_generated!
-      else
-        GraphWeaver.load_generated!
-      end
+  # can't load until that constant resolves — and both Zeitwerk's setup and the
+  # app's own to_prepare blocks (where extend_type/register_enum are told to
+  # register, Codegen::AUTOLOAD_HINT) happen after config/initializers.
+  # after_initialize is past all of them, and past the watcher above.
+  #
+  # Except where the app eager loads: an eager-loaded class may name a
+  # generated constant in its class body, and Zeitwerk can't resolve one (the
+  # directory is ignored, by design), so the modules have to be in place before
+  # Rails' :eager_load! rather than after it. before_eager_load is that point,
+  # and Rails only runs it when config.eager_load is on — which is exactly when
+  # after_initialize must not do the work a second time.
+  config.before_eager_load { GraphWeaver::Railtie.prepare_generated! }
+
+  config.after_initialize do |app|
+    GraphWeaver::Railtie.prepare_generated! unless app.config.eager_load
+    # and again on every dev reload, which picks up a module generated since
+    # boot and re-requires one whose namespace Zeitwerk just unloaded. On the
+    # reloader itself, not config.to_prepare: the :add_to_prepare_blocks
+    # finisher has already drained that list by now.
+    ActiveSupport::Reloader.to_prepare { GraphWeaver::Railtie.prepare_generated! }
+  end
+
+  def self.prepare_generated!
+    # The graph_weaver tasks write these files and need none of them loaded.
+    # Loading them would let a stale one block its own repair: a dropped
+    # extend_type leaves a dangling include, and generate depends on
+    # :environment, so boot failed before the task that would regenerate it.
+    return if GraphWeaver.skip_generated_load
+
+    # every graph is declared by now, and this is the last point before one of
+    # them loads
+    check_generated_ignored!
+
+    # Regenerate first, then load — and here rather than in the watcher's own
+    # to_run, so an extend_type or register_enum the app registers in its own
+    # to_prepare is already in place. A run that regenerated has already
+    # reloaded what it wrote.
+    return if watcher&.execute_if_updated
+
+    # entries may be globs, so Dir[] rather than Dir.exist?
+    generated = GraphWeaver::Internal::Util.generated_dirs.any? do |dir|
+      Dir[GraphWeaver::Internal::Util.resolve(dir)].any?
+    end
+    return unless generated
+
+    # `require` no-ops on a file it has already read — which is what we want,
+    # except when the constant that file defined is gone. A graph's
+    # `namespace:` is normally a module Zeitwerk owns (app/graphql/accounts/
+    # implies Accounts), and unloading it on a dev reload takes the generated
+    # module nested inside it with it; require then restores nothing and every
+    # request 500s on "uninitialized constant Accounts::PersonQuery" until a
+    # .graphql edit happens to trigger the watcher. An un-namespaced module
+    # defines a top-level constant Zeitwerk never manages, so it survives.
+    if GraphWeaver.graphs.any?(&:namespace)
+      GraphWeaver.reload_generated!
+    else
+      GraphWeaver.load_generated!
     end
   end
 end

data/lib/graph_weaver/testing.rb

@@ -388,6 +388,107 @@ module GraphWeaver
       # The configured directory as a real path — a rake task or an rspec run
       # starts from wherever it starts from; the cassettes don't move.
       def cassette_dir = Internal::Util.resolve(config.cassette_dir)
+
+      # Whether a scalar's two definitions agree: the server's
+      # coerce_input/coerce_result, and your register_scalar. No schema
+      # carries the server's half — a scalar's SDL is its name and a url —
+      # so nothing `verify`, `schema:diff` or `generate` reads can say. A
+      # schema CLASS carries both, and this runs them against each other.
+      #
+      # Per scalar the schema declares and your app registered: fabricate a
+      # value the way :fake does, cast it, send it back out through
+      # `serialize:`, through the server's `coerce_input` and `coerce_result`,
+      # and back through `cast:`. Raises naming every scalar that disagreed
+      # and how; silent when they all agree.
+      #
+      # Pass the schema CLASS. A dump's scalars pass values through, so
+      # against one this checks only that a registration's `cast:` accepts
+      # what its own `serialize:` writes — which is worth knowing, and is not
+      # the same question.
+      #
+      # The fabricated value is what the check has to work with, so pin the
+      # one that matters where it matters —
+      # `config.overrides = { "Decimal" => "123456789.123456789" }` is how
+      # the precision case gets exercised at all.
+      def check_scalars!(schema)
+        registry = Internal::Util.registry_for(schema)
+        values = Internal::Values.new(seed: 0, schema:, registry:)
+        context = GraphQL::Query.new(schema, "{ __typename }").context
+
+        disagreed = schema.types.values.sort_by(&:graphql_name).filter_map do |type|
+          next unless type.kind.name == "SCALAR"
+          # the built-in entries are the library's own; it is your
+          # registration that can be wrong about this server
+          next if registry.builtin_scalar?(type.graphql_name) ||
+            !registry.scalar_registry.key?(type.graphql_name)
+
+          disagreement(registry.scalar(type.graphql_name), type, values, context)
+        end
+        return if disagreed.empty?
+
+        raise GraphWeaver::Error, "#{disagreed.size} scalar(s) disagree with #{schema}:\n" +
+          disagreed.map { |line| "  #{line}" }.join("\n")
+      end
+
+      private
+
+      # One scalar's verdict, or nil when the two halves agree. Each step is
+      # a different mistake, so each says which.
+      def disagreement(scalar, type, values, context)
+        name = type.graphql_name
+        # a scalar registered as your own class has no fabricable value, and
+        # it says how to pin one — reported here rather than raised, so one
+        # unpinned scalar doesn't hide the verdict on all the others
+        begin
+          wire = values.scalar(name, name)
+        rescue GraphWeaver::Error => e
+          return "#{name}: #{e.message}"
+        end
+
+        cast = cast_proc(scalar)
+        begin
+          sample = cast.call(wire)
+        rescue StandardError => e
+          return "#{name}: cast: can't read #{wire.inspect}, the value fabricated for it (#{e.message}) " \
+            "— pin the form this server sends: overrides: { #{name.inspect} => ... }"
+        end
+
+        if scalar.serialize? && !scalar.serialize_value?
+          return "#{name}: serialize: is a Proc, which builds source for the generated file rather " \
+            "than converting a value, so there is nothing here to run it against"
+        end
+
+        out = scalar.serialize_value(sample)
+        refused = "#{name}: the server refused #{out.inspect}, the wire form serialize: writes"
+        begin
+          received = type.coerce_input(out, context)
+        rescue StandardError => e
+          return "#{refused} (#{e.message})"
+        end
+        return "#{refused} (coerce_input returned nil)" if received.nil? && !out.nil?
+
+        result = type.coerce_result(received, context)
+        begin
+          back = cast.call(result)
+        rescue StandardError => e
+          return "#{name}: cast: refused #{result.inspect}, the result form the server's " \
+            "coerce_result writes (#{e.message})"
+        end
+        return if back == sample
+
+        "#{name}: round-trips lossily — sent #{sample.inspect}, got back #{back.inspect}"
+      end
+
+      # The registration's `cast:`, RUN rather than emitted. A cast builds
+      # SOURCE for the generated file, so evaluating it is the only way to
+      # run one — at the top level, where a generated file's own constants
+      # resolve from.
+      def cast_proc(scalar)
+        source = scalar.cast("wire")
+        return ->(wire) { wire } if source.nil?
+
+        eval("->(wire) { #{source} }", TOPLEVEL_BINDING, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      end
     end
   end
 end

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.7.2"
+  VERSION = "0.7.4"
 end