graph_weaver 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef7de8e2cd115b4c757a3dac2e8c41a0e87865914e246131c1037a231f7a60af
-  data.tar.gz: fa89ee78a04a2a07b7c173c82685490ca501a2a29045ef487aae3dd6f3d915d8
+  metadata.gz: bdb688c1c86ee0e39da82446622479aeb99b887866326e892133efbabe8c5a3d
+  data.tar.gz: 9c5514556bbfb08b337d09be7df71d081eafe7b6ee678f658f5bf6086367fada
 SHA512:
-  metadata.gz: 4ae73ed74389baa1f08a42e38b7bf2b0bca2f95ccbe247ccb68fda733c9fee849aed3d17dbba424bdb13104344771d9789401710a5add195c71873edc379530b
-  data.tar.gz: 24e15e7a6213c0cd5dee16aa73e675649748b84993be11387f638aeca21c15db77a59b1fa5a85ae406af7182be0f9f6a17164b842add3627a7547ab1670616d1
+  metadata.gz: 752fb13032272b5a9da29f549474444865a34552c336a32bb10316ec2c3bd38dd2996cc57604b30ca505ea35045f9abbd6d0bdefd0507d19714f3ab75f7dbc4d
+  data.tar.gz: ebce80c4ad9c3c471e086616f48afb83ea6e6741e7f1c44986bb5b7ba9f57112d144443e15a5b2b78e26297c20d2e2f8a9a4777559242a77f21ca2d4d25d1031

data/CHANGELOG.md

@@ -1,3 +1,46 @@
+###  v0.2.1  (2026-07-13)
+- Conventional paths are appendable lists: queries_paths /
+  generated_paths (singular accessors read the first entry, so existing
+  config keeps working); load_generated!, Client#load_queries!, and the
+  Railtie walk every entry — append spec/support/graphql/* from a spec
+  helper to load test-only queries. Entries may be globs, and the
+  generated default includes app/graphql/*/generated so per-schema
+  layouts auto-load
+- inputs_module derives from the output path: multi-schema layouts name
+  each schema's module after its directory
+  (app/graphql/github/generated -> GithubInputs), the conventional
+  layout keeps GraphQLInputs; GraphWeaver.inputs_module= and
+  generate!(inputs_module:) still override
+- Shared types split one-file-per-type: generated/inputs/ holds each
+  input struct/enum in its own small file (PokeAPI: 573 files, median
+  24 lines vs one 11.5k-line blob) with inputs.rb as the manifest
+  (forward declarations make load order irrelevant); regeneration
+  prunes files for types the schema dropped, verify flags strays;
+  generate!/verify take inputs_module: per invocation (multi-schema
+  apps generate into different modules)
+- Shared input types: generate! emits every variable type (input
+  structs + their enums + mapped-enum tables) ONCE per schema into
+  generated/inputs.rb (module GraphQLInputs; GraphWeaver.inputs_module=
+  renames, shared_inputs: false opts out), with query modules aliasing
+  only what their own surface references — AdoptQuery::AdoptionInput
+  keeps working and shared types gain one identity across modules.
+  Three filtered Hasura queries: 34,684 lines inline -> 11,754 shared
+  (~90 lines per query module)
+- BREAKING (vs 0.2.0): auto_fake is opt-in again — require
+  "graph_weaver/rspec" no longer swaps every example onto a fake;
+  set config.auto_fake = true explicitly (the schema still auto-locates
+  once you do). Less magic, no unexpected behavior
+- Generated input structs are table-driven: typed consts + a per-field
+  FIELDS table (conversions as lambdas) interpreted by the
+  GraphWeaver::InputStruct runtime, replacing unrolled
+  serialize/coerce/value_at per struct — a bool_exp-heavy PokeAPI module
+  shrinks 29k -> 11.5k lines (-60%) with identical behavior (nil
+  omission, wire-value enums, nested/recursive coercion, spellchecked
+  unknown keys all covered by the existing suite)
+- Internal: Node base class for the codegen IR protocol; module
+  assembly moved from Codegen#generate into Emit#emit_module
+  (byte-identical output)
+
 ###  v0.2.0  (2026-07-12)
 - Cleanup pass (staff-engineer review): scalar registrations get the
   same typo validation as enums/types; cassette replay stops recomputing

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graph_weaver (0.2.0)
+    graph_weaver (0.2.1)
       graphql (>= 2)
       sorbet-runtime
 
@@ -183,7 +183,7 @@ 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.0)
+  graph_weaver (0.2.1)
   graphql (2.6.5) sha256=1051825bfb4aedb4293cdbcd9726c3150e69e3512556609a32c2ca19d4be3d00
   i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
   io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc

data/PLAN.md

@@ -105,6 +105,13 @@ Response envelope; execute! for raise-or-result).
 
 ## From the field-test experiments (2026-07-12)
 
+Generated-module size (2026-07-12, post-0.2.0): input structs are now
+table-driven (InputStruct runtime + FIELDS) — the PokeAPI filtered-query
+module dropped 29,233 -> 11,562 lines. The floor is ~2 lines/field
+(typed const + FIELDS entry). Remaining lever if it matters again:
+shared input structs emitted once per schema instead of per module.
+
+
 A junior + senior agent pair exercised the repo cold (clone, examples,
 extensions, a Pokedex app against Hasura's 4,441-type PokeAPI schema).
 Fixed same-day: snake_case type names generated invalid constants

data/docs/generated_modules.md

@@ -21,7 +21,10 @@ fails when the two drift. The conventional layout (configurable via
 app/graphql/
   schema.json        # introspection dump (or schema.graphql SDL)
   queries/           # *.graphql — hand-written, reviewed
-  generated/         # *_query.rb — generated, checked in, never edited
+  generated/
+    inputs.rb        # manifest: requires + forward declarations
+    inputs/          # one file per shared type (input structs, enums)
+    *_query.rb       # one module per query — generated, checked in, never edited
 ```
 
 The schema dump is step 0 — codegen reads it, never a live endpoint.
@@ -58,6 +61,20 @@ first). Elsewhere it's explicit, factory_bot-style:
 GraphWeaver.load_generated!   # require every file under generated_path
 ```
 
+The conventional paths are lists (entries may be globs — the default
+includes `app/graphql/*/generated`, so per-schema layouts load too).
+Append extra locations (a test-only schema, an engine's queries) and
+every loader walks them all:
+
+```ruby
+# e.g. in spec/support/graph_weaver.rb
+GraphWeaver.generated_paths << "spec/support/graphql/generated"
+GraphWeaver.queries_paths << "spec/support/graphql/queries"
+```
+
+The singular accessors (`generated_path` etc.) read and replace the
+first entry — the default target for `generate!` and the rake tasks.
+
 (Plain requires, not Zeitwerk: Zeitwerk would expect
 `Generated::PersonQuery` from `generated/person_query.rb`, and generated
 code only changes on regeneration — restart, like a schema migration.)
@@ -152,9 +169,31 @@ hint rather than silently dropping):
 AdoptQuery.execute!(input: { name: "Rex", species: "DOG" }, detail: true)
 ```
 
-The structs themselves are module-level (`AdoptQuery::AdoptionInput`) with
-`serialize` (aliased as `to_h`) producing the wire hash — optional fields
-default nil and stay off the wire. Nested inputs work (dependencies emit
+In the generate! workflow, input types (and the enums they use) are
+emitted **once per schema** — one file per type under
+`generated/inputs/`, with `inputs.rb` as the manifest. The module is
+named from the output path: the conventional layout gets
+`GraphQLInputs`, while a multi-schema layout names each schema's module
+after its directory (`app/graphql/github/generated` → `GithubInputs`).
+Override globally with `GraphWeaver.inputs_module=` or per run with
+`generate!(inputs_module:)`; opt out with
+`generate!(shared_inputs: false)`. Per-type files keep schema drift
+reviewable: a migration diffs exactly the types it touched, and types
+the schema drops are pruned on regeneration (`verify` flags strays).
+Query modules alias what they touch,
+so `AdoptQuery::AdoptionInput` still works and shared types keep one
+identity across modules — three filtered Hasura queries cost one ~11k-line
+inputs file plus ~90 lines each, instead of ~35k lines of duplicates.
+Deeply nested types live unaliased in the shared module
+(`GraphQLInputs::PetFilter`). Dynamic `parse` stays self-contained.
+
+The structs themselves are module-level (`AdoptQuery::AdoptionInput`):
+typed consts plus a compact per-field `FIELDS` table that the
+`GraphWeaver::InputStruct` runtime drives — `serialize` (aliased `to_h`)
+produces the wire hash with nil optionals omitted, `coerce` builds from
+plain hashes. The conversions ship in the generated file as data
+(lambdas in the table), so a Hasura `bool_exp` pulling hundreds of input
+types stays ~2 lines per field instead of unrolled methods. Nested inputs work (dependencies emit
 first), including recursive ones — Hasura's self-referential `bool_exp`
 filters generate cleanly (`_and:`/`_not:` fields typed as the struct
 itself), so variable-driven filtering works:

data/docs/getting_started.md

@@ -91,14 +91,16 @@ PersonQuery.execute!(id: "1").person&.name   # typed, via GraphWeaver.client
 ```ruby
 # spec/support/graph_weaver.rb
 require "graph_weaver/rspec"
+
+GraphWeaver::Testing.configure { |config| config.auto_fake = true }
 ```
 
-That's the whole setup: the schema auto-locates from the committed dump
-and `auto_fake` defaults on, so every query in every example executes
-against a seeded, schema-correct `FakeClient` — no server, no stubs,
-and `rspec --seed 1234` reproduces the fake data along with test order.
-Pin values with `overrides:`, simulate failures with `Failure.*`, opt
-out with `config.auto_fake = false` — see [testing](testing.md).
+The opt-in is deliberate (no surprise fakes); once on, the schema
+auto-locates from the committed dump and every query in every example
+executes against a seeded, schema-correct `FakeClient` — no server, no
+stubs, and `rspec --seed 1234` reproduces the fake data along with test
+order. Pin values with `overrides:`, simulate failures with `Failure.*`
+— see [testing](testing.md).
 
 ## 7. Verify in CI
 

data/docs/testing.md

@@ -31,24 +31,22 @@ GraphWeaver::Testing::FakeClient.new(schema:, overrides: {
 })
 ```
 
-With rspec, one line in `spec/support/graph_weaver.rb` is the whole
-default setup — the schema auto-locates from the committed dump at
-`GraphWeaver.schema_path`, and `auto_fake` defaults on:
+With rspec, the setup is two lines in `spec/support/graph_weaver.rb` —
+the require, plus an explicit opt-in to per-example fakes (deliberately
+not a default: silently swapping every example onto a fake would be
+surprising). The schema auto-locates from the committed dump at
+`GraphWeaver.schema_path`:
 
 ```ruby
-require "graph_weaver/rspec"   # seed follows --seed; every example auto-fakes
-```
-
-Configure to override any of it:
+require "graph_weaver/rspec"   # seed follows --seed
 
-```ruby
 GraphWeaver::Testing.configure do |config|
-  config.schema = MySchema             # an in-process class instead of the located dump
-  config.auto_fake = false             # opt out of per-example fakes
-  config.mode = :faker                 # or :literal (plain typed values); nil = auto
-  config.overrides = { "Person.name" => "Daniel" }
-  config.list_size = 1..3
-  config.null_chance = 0.1             # nullable fields go nil sometimes
+  config.auto_fake = true              # every example runs against a fresh fake
+  # config.schema = MySchema           # optional: an in-process class instead of the dump
+  # config.mode = :faker               # or :literal (plain typed values); nil = auto
+  # config.overrides = { "Person.name" => "Daniel" }
+  # config.list_size = 1..3
+  # config.null_chance = 0.1           # nullable fields go nil sometimes
 end
 ```
 
@@ -59,6 +57,15 @@ they consult `GraphWeaver.client`). `mode:` picks value fabrication: `:faker`
 (semantic, field-name matched — raises if the gem is missing),
 `:literal` (plain type-derived), or nil to auto-detect faker.
 
+Test-only queries don't have to live in `app/` — the conventional paths
+are appendable lists, so the same support file can register a
+spec-local set that `load_generated!` (and the Railtie) pick up:
+
+```ruby
+GraphWeaver.generated_paths << "spec/support/graphql/generated"
+GraphWeaver.queries_paths << "spec/support/graphql/queries"
+```
+
 **Simulating failures** — every failure mode is just a client, so
 error-handling paths are testable without a server that misbehaves on cue:
 

data/lib/graph_weaver/client.rb

@@ -127,8 +127,9 @@ class GraphWeaver::Client
   #
   # Reloadable (constants are replaced), so it suits consoles and dev.
   # Returns the modules.
-  def load_queries!(dir = GraphWeaver.queries_path, namespace: Object)
-    Dir[File.join(dir, "*.graphql")].sort.map do |path|
+  def load_queries!(dir = nil, namespace: Object)
+    dirs = dir ? [dir] : GraphWeaver.queries_paths
+    dirs.flat_map { |d| Dir[File.join(d, "*.graphql")].sort }.map do |path|
       name = "#{GraphWeaver::Inflect.camelize(File.basename(path, ".graphql"))}Query"
       namespace.send(:remove_const, name) if namespace.const_defined?(name, false)
       GraphWeaver.log(:info) { "loaded #{name} from #{path}" }

data/lib/graph_weaver/codegen/emit.rb

@@ -5,10 +5,244 @@
 # Mixed into Codegen — methods run with the generator instance state.
 class GraphWeaver::Codegen
   module Emit
+    include Kernel # for sorbet: hosts are Objects
     include GraphWeaver::Inflect
 
     private
 
+    # The Relay convention — an operation whose only variable is a required
+    # input object — reads better flattened: the input's fields become
+    # execute's kwargs directly, and the wrapping level is rebuilt on the
+    # wire. Multi-variable (or nullable-input) operations keep the
+    # variable-per-kwarg surface.
+    def flatten_input(variables)
+      return unless variables.size == 1
+
+      var = variables.first
+      return unless var.required && var.node.is_a?(NonNull)
+
+      input = var.node.of
+      input if input.is_a?(InputNode)
+    end
+
+    def input_references(node)
+      node.fields.filter_map do |field|
+        child = field.node
+        child = child.of while child.respond_to?(:of)
+        child if child.is_a?(InputNode)
+      end
+    end
+
+    # Input structs in dependency order (referenced types before their
+    # referrers) so each emitted const names an already-defined class.
+    # Cycles make that impossible — flagged so emission can forward-declare
+    # every input class first, then reopen each to add its props.
+    def ordered_inputs
+      ordered = []
+      seen = {} # node => :done | :visiting (bool_exp graphs get big)
+      cyclic = T.let(false, T::Boolean)
+
+      visit = lambda do |node|
+        next if seen[node] == :done
+
+        if seen[node] == :visiting
+          cyclic = true
+          next
+        end
+
+        seen[node] = :visiting
+        input_references(node).each(&visit)
+        seen[node] = :done
+        ordered << node
+      end
+      @variable_inputs.each_value(&visit)
+
+      [ordered, cyclic]
+    end
+
+      # Mapped-enum tables, generated enums, and input structs
+      # (dependency-ordered, forward-declared when cyclic) — inline in the
+      # module that needs them, or once in the shared inputs module.
+      def emit_variable_types(out)
+          @mapped_enums.each_value do |mapped|
+            emit_mapped_enum(mapped, out, 1)
+            out << ""
+          end
+          @variable_enums.each_value do |enum|
+            emit_enum(enum, out, 1)
+            out << ""
+          end
+          inputs, cyclic = ordered_inputs
+          if cyclic
+            # Recursive input types (Hasura bool_exp et al) reference each other,
+            # so no definition order satisfies the runtime — forward-declare every
+            # class empty, then let the full definitions below reopen with props.
+            # eval'd so srb sees only the full bodies (reopening a T::Struct to
+            # add props is a static error; adding them at runtime is fine).
+            out << "  # runtime-only forward declarations: these input types reference"
+            out << "  # each other, so the full definitions below need the constants"
+            out << "  eval(<<~RUBY, binding, __FILE__, __LINE__ + 1)"
+            inputs.each { |input| out << "    class #{input.class_name} < T::Struct; end" }
+            out << "  RUBY"
+            out << ""
+          end
+          inputs.each do |input|
+            emit_input(input, out, 1)
+            out << ""
+          end
+        end
+
+      # In the shared-inputs workflow the variable types live once in the
+      # inputs module; the query module aliases what it uses, so
+      # AdoptQuery::AdoptionInput stays a real constant — and shared types
+      # keep ONE identity across every module that touches them.
+      # Only the shared names THIS module's emission references: variable
+      # root types (and, when flattened, the root input's field types)
+      # plus every mapped-enum table (result casting reads them too).
+      # Nested types stay un-aliased — they live in the inputs module.
+      def shared_alias_names(variables, flatten)
+        nodes = variables.map(&:node)
+        nodes += flatten.fields.map(&:node) if flatten
+
+        names = @mapped_enums.each_value.flat_map { |m| ["#{m.const_prefix}_FROM_WIRE", "#{m.const_prefix}_TO_WIRE"] }
+        nodes.each do |wrapped|
+          node = T.let(wrapped, T.untyped)
+          node = node.of while node.is_a?(NonNull) || node.is_a?(List)
+          case node
+          when EnumNode, InputNode then names << node.class_name
+          end
+        end
+        names.uniq
+      end
+
+      def emit_shared_aliases(out, names)
+        return if names.empty?
+
+        names.each { |name| out << "  #{name} = #{@inputs_namespace}::#{name}" }
+        out << ""
+      end
+
+      # The shared inputs artifact as files: inputs.rb (the manifest —
+      # requires, forward declarations for every struct so definition
+      # order never matters, then one require per type file) plus
+      # inputs/<type>.rb per enum/mapped-table/input struct.
+      def emit_inputs_files
+        files = {}
+        enum_files = []
+        struct_files = []
+
+        @mapped_enums.each do |graphql_name, mapped|
+          enum_files << inputs_file(files, graphql_name) { |out| emit_mapped_enum(mapped, out, 1) }
+        end
+        @variable_enums.each do |graphql_name, enum|
+          enum_files << inputs_file(files, graphql_name) { |out| emit_enum(enum, out, 1) }
+        end
+        inputs, = ordered_inputs
+        inputs.each do |input|
+          struct_files << inputs_file(files, input.class_name) { |out| emit_input(input, out, 1) }
+        end
+
+        manifest = []
+        manifest << "# typed: strict"
+        manifest << "# frozen_string_literal: true"
+        manifest << ""
+        manifest << "# Generated by GraphWeaver — do not edit. Shared variable types for"
+        manifest << "# this schema, one file per type; query modules alias what they use."
+        manifest << ""
+        requires = @requires.uniq.sort
+        if requires.any?
+          requires.each { |req| manifest << "require #{req.inspect}" }
+          manifest << ""
+        end
+        manifest << "module #{@module_name}; end"
+        manifest << ""
+        enum_files.sort.each { |file| manifest << "require_relative #{file.delete_suffix(".rb").inspect}" }
+        if inputs.any?
+          manifest << ""
+          manifest << "# runtime-only forward declarations: input types reference each"
+          manifest << "# other across files, so every constant must exist before any"
+          manifest << "# definition loads (srb sees only the full bodies)"
+          manifest << "module #{@module_name}"
+          manifest << "  eval(<<~RUBY, binding, __FILE__, __LINE__ + 1)"
+          inputs.each { |input| manifest << "    class #{input.class_name} < T::Struct; end" }
+          manifest << "  RUBY"
+          manifest << "end"
+          manifest << ""
+          struct_files.sort.each { |file| manifest << "require_relative #{file.delete_suffix(".rb").inspect}" }
+        end
+
+        files["inputs.rb"] = manifest.join("\n") + "\n"
+        files
+      end
+
+      # one type per file, wrapped in the namespace so bare sibling
+      # references resolve lexically
+      def inputs_file(files, name)
+        out = []
+        out << "# typed: strict"
+        out << "# frozen_string_literal: true"
+        out << ""
+        out << "# Generated by GraphWeaver — do not edit."
+        out << ""
+        out << "module #{@module_name}"
+        yield(out)
+        out << "end"
+
+        file = "inputs/#{GraphWeaver::Inflect.underscore(name)}.rb"
+        files[file] = out.join("\n") + "\n"
+        file
+      end
+
+    # The whole generated file: header, requires, the QUERY heredoc,
+    # enum tables, input structs (dependency-ordered, forward-declared
+    # when cyclic), the Result tree, and execute — assembled from the
+    # generator's walked state.
+    def emit_module(root, variables)
+      flatten = flatten_input(variables)
+      aliases = @inputs_namespace ? shared_alias_names(variables, flatten) : []
+
+      out = []
+      out << "# typed: strict"
+      out << "# frozen_string_literal: true"
+      out << ""
+      out << "# Generated by GraphWeaver — do not edit."
+      out << ""
+      requires = @requires.uniq.sort
+      if requires.any?
+        requires.each { |req| out << "require #{req.inspect}" }
+        out << ""
+      end
+      if aliases.any?
+        # the aliases below need the shared module loaded (same directory
+        # by the generate! convention)
+        out << "require_relative \"inputs\""
+        out << ""
+      end
+      out << "module #{@module_name}"
+      out << "  extend T::Sig"
+      out << ""
+      # a GraphQL block string could contain a bare GRAPHQL line, which
+      # would terminate the heredoc early — pick a delimiter the query
+      # can't collide with
+      delimiter = "GRAPHQL"
+      delimiter += "_" while @query.match?(/^\s*#{delimiter}\s*$/)
+      out << "  QUERY = T.let(<<~'#{delimiter}', String)"
+      @query.each_line { |line| out << "    #{line}".rstrip }
+      out << "  #{delimiter}"
+      out << ""
+      if @inputs_namespace
+        emit_shared_aliases(out, aliases)
+      else
+        emit_variable_types(out)
+      end
+      emit_nested(root, out, 1)
+      out << ""
+      emit_execute(out, variables, flatten:)
+      out << "end"
+
+      out.join("\n") + "\n"
+    end
+
     def emit_nested(node, out, indent)
       case node
       when UnionNode then emit_union(node, out, indent)
@@ -212,74 +446,30 @@ class GraphWeaver::Codegen
       end
     end
 
-    # a module-level T::Struct per input type; serialize builds the wire
-    # hash, omitting optional fields left nil
+    # A module-level T::Struct per input type: typed consts plus a FIELDS
+    # table the GraphWeaver::InputStruct runtime drives — serialize/to_h/
+    # coerce live once in the gem, not unrolled per struct (bool_exp
+    # schemas pull hundreds of inputs into one module).
     def emit_input(node, out, indent)
       pad = "  " * indent
 
       out << "#{pad}class #{node.class_name} < T::Struct"
-      out << "#{pad}  extend T::Sig"
+      out << "#{pad}  include GraphWeaver::InputStruct"
+      out << "#{pad}  extend GraphWeaver::InputStruct::ClassMethods"
       out << ""
       node.fields.each do |field|
         default = field.required ? "" : ", default: nil"
         out << "#{pad}  const :#{field.prop}, #{field.node.prop_type}#{default}"
       end
       out << ""
-      # locals wear the reserved __gw prefix: prop readers are bare method
-      # calls here, and a prop named "result" or "value" would otherwise
-      # be shadowed — GraphQL reserves __-names, so no field can collide
-      out << "#{pad}  sig { returns(T::Hash[String, T.untyped]) }"
-      out << "#{pad}  def serialize"
-      out << "#{pad}    __gw_result = T.let({}, T::Hash[String, T.untyped])"
+      out << "#{pad}  # (prop, wire, required, serializer, coercer) per field"
+      out << "#{pad}  FIELDS = T.let(["
       node.fields.each do |field|
-        if field.required || field.node.serialize_identity?
-          value = field.node.serialize_identity? ? field.prop.to_s : field.node.serialize(field.prop.to_s, 1)
-          line = "__gw_result[#{field.wire.inspect}] = #{value}"
-          line += " unless #{field.prop}.nil?" unless field.required
-          out << "#{pad}    #{line}"
-        else
-          # bind a local so sorbet's flow-sensitivity narrows the nilable
-          out << "#{pad}    unless (__gw_value = #{field.prop}).nil?"
-          out << "#{pad}      __gw_result[#{field.wire.inspect}] = #{field.node.serialize("__gw_value", 1)}"
-          out << "#{pad}    end"
-        end
+        serializer = field.node.serialize_identity? ? "nil" : "->(v) { #{field.node.serialize("v", 1)} }"
+        coercer = field.node.hash_coerce_identity? ? "nil" : "->(v) { #{field.node.hash_coerce("v", 1)} }"
+        out << "#{pad}    GraphWeaver::InputStruct::Field.new(:#{field.prop}, #{field.wire.inspect}, #{field.required}, #{serializer}, #{coercer}),"
       end
-      out << "#{pad}    __gw_result"
-      out << "#{pad}  end"
-      out << ""
-      out << "#{pad}  # serialize, under the conventional name"
-      out << "#{pad}  sig { returns(T::Hash[String, T.untyped]) }"
-      out << "#{pad}  def to_h = serialize"
-      out << ""
-      out << "#{pad}  # Build from a plain hash (underscored keys, Symbol or String):"
-      out << "#{pad}  # enums accept their wire values, nested inputs accept hashes;"
-      out << "#{pad}  # the struct's types are enforced on construction."
-      out << "#{pad}  sig { params(value: T.any(#{node.class_name}, T::Hash[T.untyped, T.untyped])).returns(#{node.class_name}) }"
-      out << "#{pad}  def self.coerce(value)"
-      out << "#{pad}    return value if value.is_a?(#{node.class_name})"
-      out << ""
-      out << "#{pad}    # a typo'd key must not silently drop off the wire"
-      out << "#{pad}    GraphWeaver::Hints.validate_keys!(self, value)"
-      out << ""
-      out << "#{pad}    new("
-      node.fields.each do |field|
-        raw = "value_at(value, :#{field.prop})"
-        expr = if field.node.hash_coerce_identity?
-          raw
-        elsif field.required
-          "#{raw}.then { |v1| #{field.node.hash_coerce("v1", 2)} }"
-        else
-          "#{raw}&.then { |v1| #{field.node.hash_coerce("v1", 2)} }"
-        end
-        out << "#{pad}      #{field.prop}: #{expr},"
-      end
-      out << "#{pad}    )"
-      out << "#{pad}  end"
-      out << ""
-      out << "#{pad}  sig { params(hash: T::Hash[T.untyped, T.untyped], key: Symbol).returns(T.untyped) }"
-      out << "#{pad}  private_class_method def self.value_at(hash, key)"
-      out << "#{pad}    hash.key?(key) ? hash[key] : hash[key.to_s]"
-      out << "#{pad}  end"
+      out << "#{pad}  ].freeze, T::Array[GraphWeaver::InputStruct::Field])"
       out << "#{pad}end"
     end
   end