graph_weaver 0.5.0 → 0.5.1

data/lib/graph_weaver/codegen/scalar_type.rb

@@ -171,10 +171,6 @@ class GraphWeaver::Codegen
     end
   end
 
-  # Pre-registered rather than user intent (see register_builtin_scalars!), so
-  # generation doesn't hold a schema to them.
-  BUILTIN_SCALARS = %w[ID String Int Float Boolean Date].freeze
-
   class << self
     # requires: is a require path or list of them; each must be a non-empty
     # String (it is emitted verbatim as `require "..."` atop the generated
@@ -258,4 +254,9 @@ class GraphWeaver::Codegen
   end
 
   register_builtin_scalars!
+
+  # Pre-registered rather than user intent, so generation doesn't hold a schema
+  # to them (validate_registration! skips these). Read off the registry the line
+  # above just filled: a seventh built-in shouldn't have to be named twice.
+  BUILTIN_SCALARS = scalar_registry.keys.freeze
 end

data/lib/graph_weaver/codegen/type_helpers.rb

@@ -54,9 +54,7 @@ class GraphWeaver::Codegen
         # won't resolve yet — see EnumType for why that's a Rails initializer
         if mixin.is_a?(String)
           raise ArgumentError, "type helpers are the modules themselves, not their names — " \
-            "extend_type(#{graphql_name.to_s.inspect}, #{mixin}). An autoloaded constant isn't " \
-            "resolvable while config/initializers run; register from a " \
-            "Rails.application.config.to_prepare block, which generation also runs first."
+            "extend_type(#{graphql_name.to_s.inspect}, #{mixin}). #{GraphWeaver::Codegen::AUTOLOAD_HINT}"
         end
         unless mixin.is_a?(Module) && mixin.name
           raise ArgumentError, "type helpers must be named modules, got #{mixin.inspect}"

data/lib/graph_weaver/codegen.rb

@@ -15,12 +15,14 @@ require "sorbet-runtime"
 # T::Enum), and typed variables (kwargs on execute). Subscriptions are
 # still open.
 #
-# Split across: codegen/scalar_type.rb (the scalar registry),
-# codegen/nodes.rb (the typed IR), codegen/aliases.rb (registered alias
-# paths), codegen/emit.rb (source emission); this file holds the public
-# API and the query walk.
+# Split across: codegen/scalar_type.rb and codegen/enum_type.rb (the leaf
+# registries), codegen/type_helpers.rb (extend_type and the alias/mixin
+# registry), codegen/nodes.rb (the typed IR), codegen/aliases.rb (resolving
+# registered alias paths against a node), codegen/emit.rb (source emission);
+# this file holds the public API and the query walk.
 require_relative "hints"
 require_relative "input_struct"
+require_relative "schema_loader"
 require_relative "representation"
 require_relative "inflect"
 require_relative "selection"
@@ -41,6 +43,13 @@ class GraphWeaver::Codegen
   # how anyone with sixty queries organizes them.
   DOCUMENT_GLOB = "**/*.{graphql,gql}"
 
+  # Why every registration takes the constant and never its name. register_enum
+  # and extend_type refuse a String for the same reason, so they say it in the
+  # same words — a reword has to reach both or one starts giving worse advice.
+  AUTOLOAD_HINT = "An autoloaded constant isn't resolvable while config/initializers " \
+    "run; register from a Rails.application.config.to_prepare block, which generation " \
+    "also runs first."
+
   attr_reader :module_name
 
   # A client is anything responding to `execute(query, variables:)`
@@ -436,22 +445,15 @@ class GraphWeaver::Codegen
   end
 
   # A @key field set is a GraphQL selection set — "upc sku", or a nested
-  # "id organization { id }" — so parse it and flatten to the leaf paths the
-  # wire hash needs. Dotted, since a GraphQL name can't contain a dot.
+  # "id organization { id }" — flattened to the dotted leaf paths the wire
+  # hash needs. The same reading the routing table does of the same syntax,
+  # so a supergraph and a subgraph SDL can't disagree about one key.
   def key_paths(entity, fields)
-    selections = GraphQL.parse("{ #{fields} }").definitions.first.selections
-    leaf_paths(selections)
+    GraphWeaver::SchemaLoader::RoutingTable.parse_field_set(fields)
   rescue GraphQL::ParseError => e
     raise GraphWeaver::Error, "#{entity.graphql_name} @key(fields: #{fields.inspect}) isn't a selection set: #{e.message}"
   end
 
-  def leaf_paths(selections, prefix = [])
-    selections.flat_map do |node|
-      path = prefix + [node.name]
-      node.selections.empty? ? [path.join(".")] : leaf_paths(node.selections, path)
-    end
-  end
-
   # The kwargs a builder takes: every key set's top-level field, once. Typed
   # from the schema — a leaf key field gets its registered scalar's Ruby
   # type, a nested one an open Hash whose shape the runtime checks.
@@ -632,6 +634,29 @@ class GraphWeaver::Codegen
     end
   end
 
+  # The @include/@skip a fragment carries applies to what it guards, so it has
+  # to travel with the selections into the child rather than being spent on the
+  # key. Re-wrapping in a guarded inline fragment says that in the vocabulary
+  # the walk already speaks, which is what keeps dispatchable_typename? and the
+  # __typename refusal honest for free.
+  GUARDED = [GraphQL::Language::Nodes::Directive.new(name: "include")].freeze
+  private_constant :GUARDED
+
+  # A key's merged sub-selections, keeping the conditionality of the occurrence
+  # each child came from: `pets @include(if:) { name } pets { species }` answers
+  # with `name` only when that occurrence ran, so those children have to admit
+  # nil. One occurrence needs none of this — the key is there exactly when it
+  # ran, and its own prop already says so.
+  def merged_selections(occurrences)
+    return occurrences.first.first.selections if occurrences.one?
+
+    occurrences.flat_map do |node, conditional|
+      next node.selections unless conditional || conditional?(node)
+
+      [GraphQL::Language::Nodes::InlineFragment.new(type: nil, directives: GUARDED, selections: node.selections)]
+    end
+  end
+
   def object_node(type, selections, class_name)
     node = ObjectNode.new(class_name)
     node.graphql_type = type.graphql_name
@@ -653,7 +678,7 @@ class GraphWeaver::Codegen
         NonNull.new(scalar_node("String"))
       else
         field_type = @schema.get_field(type.graphql_name, field_name).type
-        sub_selections = field_nodes.flat_map(&:selections)
+        sub_selections = merged_selections(occurrences)
 
         case (core = field_type.unwrap).kind.name
         when "OBJECT"
@@ -822,7 +847,10 @@ class GraphWeaver::Codegen
   def nilable_type_ref(type, &core)
     case type.kind.name
     when "NON_NULL"
-      nilable_type_ref(type.of_type, &core)
+      # only the NON_NULL around the narrowed member itself drops — `[Thing!]!`
+      # narrowed is a guaranteed array of nilable members, not a nilable array
+      inner = nilable_type_ref(type.of_type, &core)
+      inner.is_a?(List) ? NonNull.new(inner) : inner
     when "LIST"
       List.new(nilable_type_ref(type.of_type, &core))
     else
@@ -864,11 +892,58 @@ class GraphWeaver::Codegen
 
   # The one struct everything else deserializes into: a member the query didn't
   # name, and — the point — a member the schema grows AFTER this file was
-  # generated. It carries only what the abstract type itself guarantees (an
-  # interface's selected interface-level fields; for a union, just __typename),
-  # so a new upstream member bends the result rather than breaking it.
+  # generated, so a new upstream member bends the result rather than breaking
+  # it. It carries what the abstract type itself guarantees, plus anything a
+  # `... on SomeInterface` asked for, since an unnamed member may implement it.
   def catch_all_member(type, selections, members)
-    object_node(type, selections, catch_all_name(members))
+    node = object_node(type, selections, catch_all_name(members))
+    taken = node.fields.map(&:key)
+
+    # These are nilable whatever the schema promises: the member that arrives
+    # need not implement the interface, and then the server sends nothing.
+    sibling_conditions(type, selections).each do |condition, sub_selections|
+      object_node(condition, sub_selections, node.class_name).fields.each do |field|
+        next if taken.include?(field.key)
+
+        taken << field.key
+        child = field.node
+        node.fields << ObjectNode::Field.new(field.prop, field.key, child.is_a?(NonNull) ? child.of : child)
+      end
+    end
+
+    node.aliases = resolve_aliases(node)
+    node
+  end
+
+  # The abstract type conditions inside an abstract selection that a member the
+  # query never NAMED could still satisfy — `... on Named` under a union, or
+  # under a different interface. Returns condition => merged selections, so the
+  # same interface spread twice types once; concrete conditions are excluded,
+  # since a member they'd match already has a struct of its own.
+  def sibling_conditions(type, selections, visiting = Set.new, out = {})
+    selections.each do |selection|
+      case selection
+      when GraphQL::Language::Nodes::InlineFragment
+        sibling_condition(type, selection.type&.name, selection.selections, visiting, out)
+      when GraphQL::Language::Nodes::FragmentSpread
+        next if visiting.include?(selection.name)
+
+        fragment = @fragments.fetch(selection.name)
+        sibling_condition(type, fragment.type.name, fragment.selections, visiting | [selection.name], out)
+      end
+    end
+    out
+  end
+
+  def sibling_condition(type, name, selections, visiting, out)
+    condition = name ? @schema.get_type(name) : type
+    return unless condition
+    # same type condition restated — keep descending at this level
+    return sibling_conditions(type, selections, visiting, out) if condition.graphql_name == type.graphql_name
+    return unless condition.kind.abstract?
+
+    (out[condition] ||= []).concat(selections)
+    sibling_conditions(condition, selections, visiting, out)
   end
 
   # "Other", unless a real member already claims that name.
@@ -926,7 +1001,9 @@ class GraphWeaver::Codegen
     end
   end
 
-  # the input-side core kinds a variable (or input-object field) can have
+  # The node for a core type, reached from a variable, an input-object field
+  # or a result-side enum. All three share it so that one schema enum is one
+  # Ruby type wherever it appears — see object_node's ENUM branch.
   def variable_core(core)
     case core.kind.name
     when "SCALAR"

data/lib/graph_weaver/errors.rb

@@ -189,12 +189,32 @@ module GraphWeaver
       extensions["code"] || @error_type
     end
 
-    # Message shapes servers use when they reject the *shape* of a query
-    # (unknown field/type/argument). Heuristic by necessity: only Apollo
-    # sets a standard code (GRAPHQL_VALIDATION_FAILED); graphql-ruby and
-    # GitHub speak in messages.
+    # Codes a server sets when it rejects the *shape* of a query. Apollo has
+    # one flat code; graphql-ruby names the rule that fired, and it is the
+    # in-process client this library ships, so its drift-shaped rules are
+    # listed rather than guessed at from prose.
+    VALIDATION_CODES = T.let(%w[
+      GRAPHQL_VALIDATION_FAILED
+      undefinedField undefinedType undefinedDirective
+      argumentNotAccepted argumentType argumentLiteralsIncompatible
+      missingRequiredArguments missingRequiredInputObjectAttribute
+      cannotSpreadFragment fragmentOnNonCompositeType
+      variableMismatch variableRequiresValidType variableNotDefined
+      selectionMismatch invalidOneOfInputObject
+    ].to_set.freeze, T::Set[String])
+
+    # For servers that send no code at all. Variable coercion reports through
+    # the message in both dialects, and a required input field appearing is
+    # unambiguous here: a generated input struct enforces its own required
+    # fields, so the app cannot produce that error itself.
     VALIDATION_MESSAGE = T.let(
-      /doesn't exist|Cannot query field|Unknown (field|type|argument)|isn't defined|undefined (field|type)/i,
+      Regexp.union(
+        /doesn't exist/i, /Cannot query field/i, /Unknown (field|type|argument)/i,
+        /is ?n[o']t defined/i, /undefined (field|type)/i, /No such type/i,
+        /can't be spread inside/i, /is missing required arguments/i,
+        /doesn't accept argument/i, /Field is not defined on/i,
+        /was provided invalid value for .+ \(Expected value to not be null\)/i,
+      ),
       Regexp,
     )
 
@@ -203,7 +223,8 @@ module GraphWeaver
     # changed after generation.
     sig { returns(T::Boolean) }
     def validation?
-      code == "GRAPHQL_VALIDATION_FAILED" || VALIDATION_MESSAGE.match?(message)
+      # to_s: a nil code is never a member, and sorbet can't narrow a call
+      VALIDATION_CODES.include?(code.to_s) || VALIDATION_MESSAGE.match?(message)
     end
 
     # The codes servers use to say "you're going too fast". No standard

data/lib/graph_weaver/federation.rb

@@ -78,9 +78,10 @@ module GraphWeaver
       def initialize(supergraph: nil, subgraphs: nil, schemas: nil)
         source = (supergraph || GraphWeaver::SchemaLoader.locate_path).to_s
         @table = GraphWeaver::SchemaLoader.routing_table(source)
-        # SDL passed as content has no name to print
-        @source = source.include?("\n") ? "the supergraph" : source
-        @given = named(subgraphs)
+        # SDL passed as content has no name to print — asked the way the
+        # loader asks it, which a one-line supergraph doesn't fool
+        @source = GraphWeaver::SchemaLoader.sdl_content?(source) ? "the supergraph" : source
+        @given = @table.named_subgraphs(subgraphs)
         @schemas = schemas || GraphWeaver::Schemas.loaded
         @stale = {}
         @uncomposed = {}
@@ -129,20 +130,6 @@ module GraphWeaver
       STALE = "stale — the supergraph carries these, no schema here defines them (recompose):"
       UNCOMPOSED = "not composed in — a schema here defines these, the supergraph doesn't carry them:"
 
-      # `subgraphs:` with string keys, refusing a name this supergraph
-      # doesn't have — the same check Testing::Subgraphs makes, and for the
-      # same reason: a typo'd key would silently check nothing
-      def named(given)
-        map = (given || {}).to_h { |name, schema| [name.to_s, schema] }
-        unknown = map.keys - @table.subgraphs
-        if unknown.any?
-          raise GraphWeaver::ConfigurationError, "subgraphs: names #{unknown.join(", ")}, which " \
-            "this supergraph doesn't have (its subgraphs are #{@table.subgraphs.join(", ")})"
-        end
-
-        map
-      end
-
       def compare
         @table.subgraphs.each do |name|
           next unless (fitting = comparable(name))

data/lib/graph_weaver/parsing.rb

@@ -27,7 +27,7 @@ module GraphWeaver
     def parse(query, name: nil)
       # #schema is the mixin's one requirement of its includer, and a module
       # has no way to declare that short of an abstract interface
-      GraphWeaver.parse(schema: T.unsafe(self).schema, query:, name:, client: parse_client)
+      GraphWeaver.parse(schema: T.unsafe(self).schema, query:, name:, client: self)
     end
 
     # Parse every query in a directory (subdirectories included) into typed
@@ -55,13 +55,5 @@ module GraphWeaver
         namespace.const_set(name, parse(path))
       end
     end
-
-    private
-
-    # What a parsed module executes through: this object, which holds the
-    # schema and runs queries. Client is the one that overrides it — its own
-    # #execute is the one-shot parse-and-run, not the client contract, so it
-    # bakes the transport it wraps.
-    def parse_client = self
   end
 end

data/lib/graph_weaver/rspec.rb

@@ -83,9 +83,12 @@ module GraphWeaver
         # so there is no idiom to discover and no way to leak a client forward
         rspec_config.before(:each) do
           @__graph_weaver_prior_client = GraphWeaver.client
-          @__graph_weaver_mode = GraphWeaver::Testing::RSpecIntegration.mode_for(
-            RSpec.current_example&.metadata || {},
-          )
+          metadata = RSpec.current_example&.metadata || {}
+          # what this example said, apart from what config.default_mode says
+          # for the ones that said nothing — a helper may only contradict the
+          # former
+          @__graph_weaver_tag = metadata[TAG] if metadata.key?(TAG)
+          @__graph_weaver_mode = GraphWeaver::Testing::RSpecIntegration.mode_for(metadata)
           if @__graph_weaver_mode
             GraphWeaver.client = GraphWeaver::Testing::RSpecIntegration.client_for(@__graph_weaver_mode)
           end
@@ -125,9 +128,9 @@ module GraphWeaver
         when :router
           router = config.built_router
           router.context = config.context
-          # built once for the suite, so the trace has to be told where this
-          # example starts — otherwise have_fetched reads the last one's
-          router.reset_trace
+          # built once for the suite, so it has to be told where this example
+          # starts — the trace, and any faked subgraph's fabricated data
+          router.reset!
         end
       end
 
@@ -187,7 +190,10 @@ module GraphWeaver
         # two is then a mistake, and silently letting the later one win hides
         # which.
         def claim_mode!(mode)
-          tagged = defined?(@__graph_weaver_mode) ? @__graph_weaver_mode : nil
+          # only an explicit tag can contradict a helper. config.default_mode
+          # is a fallback for examples that said nothing, so a helper is the
+          # example finally saying something — not a disagreement.
+          tagged = defined?(@__graph_weaver_tag) ? @__graph_weaver_tag : nil
           if tagged && tagged != mode
             # Kernel.raise: this module is mixed into every example group, so
             # it doesn't include Kernel for sorbet to find

data/lib/graph_weaver/schema_loader.rb

@@ -44,7 +44,6 @@ module GraphWeaver::SchemaLoader
   def self.sdl_content?(source)
     source.match?(SDL_CONTENT)
   end
-  private_class_method :sdl_content?
 
   def self.load_path(path)
     case File.extname(path)
@@ -718,8 +717,10 @@ module GraphWeaver::SchemaLoader
   end
   private_class_method :refresh_hint
 
-  # a transport to the dump's recorded url, authenticated from whichever
-  # ENV var the dump named (else GRAPHWEAVER_AUTH)
+  # A transport to the dump's recorded url, authenticated from whichever ENV
+  # var the dump named (else DEFAULT_AUTH_ENV). The single way to reach a
+  # dump's own server — building one at a call site is how `--auth MY_TOKEN`
+  # ends up honoured in some places and not others.
   def self.source_transport(path)
     meta = provenance(path)
     unless meta&.key?("url")
@@ -730,7 +731,6 @@ module GraphWeaver::SchemaLoader
 
     GraphWeaver.new(meta["url"], auth: ENV[auth_env(path)]).transport
   end
-  private_class_method :source_transport
 
   # Where a dump came from, recorded into the file so it can be
   # re-verified later — a parsable header comment in SDL, a
@@ -938,6 +938,19 @@ module GraphWeaver::SchemaLoader
       owners(type_name, field_name)
     end
 
+    # A `subgraphs:` map with string keys, refusing a name this supergraph
+    # doesn't have — a typo'd key would otherwise silently configure nothing.
+    # Lives here so the test router and the drift check refuse identically:
+    # two copies of this drifted apart once already.
+    def named_subgraphs(given)
+      map = (given || {}).to_h { |name, schema| [name.to_s, schema] }
+      unknown = map.keys - subgraphs
+      return map if unknown.empty?
+
+      raise GraphWeaver::ConfigurationError, "subgraphs: names #{unknown.join(", ")}, which " \
+        "this supergraph doesn't have (its subgraphs are #{subgraphs.join(", ")})"
+    end
+
     # The @key field sets a subgraph will answer an `_entities` fetch on, each
     # as a list of dotted paths ("id organization { id }" => ["id",
     # "organization.id"]). A `resolvable: false` key declares a shape this
@@ -994,16 +1007,27 @@ module GraphWeaver::SchemaLoader
 
     # join__Graph's enum values ARE the subgraphs: ACCOUNTS
     # @join__graph(name: "accounts", url: "...").
+    #
+    # This table reads the join spec under its default name, and only that —
+    # a supergraph that renamed it (`@link(url: ".../join/v0.3", as: "j")`)
+    # spells every marker `j__` and lands here with nothing found. Being told
+    # a composed graph has no subgraphs is worse than being refused, so an
+    # empty read is `unsupported` rather than an answer.
     def read_graphs
       enum = @document.definitions.find do |defn|
         defn.is_a?(GraphQL::Language::Nodes::EnumTypeDefinition) && defn.name == "join__Graph"
       end
-      return unless enum
 
-      enum.values.each do |value|
+      enum&.values&.each do |value|
         name = argument(value.directives.find { |d| d.name == "join__graph" }, "name")
         @names[value.name] = name if name
       end
+
+      return if @names.any?
+
+      @unsupported << "no join__Graph enum names the subgraphs — this schema declares a " \
+        "composition spec, so either it merged nothing, or it renamed the join spec " \
+        "(@link(url: \".../join/v0.3\", as: \"...\")), which this table doesn't follow"
     end
 
     # What each abstract type can be, from the SDL alone — a union's members,

data/lib/graph_weaver/schemas.rb

@@ -12,8 +12,10 @@ module GraphWeaver
   # Two features ask exactly these two questions, and match a schema on the
   # coordinates it defines rather than on its class name: {Testing::Subgraphs}
   # (which schema serves which subgraph) and {Federation::Drift} (has a
-  # subgraph changed without a recompose). They share the answers so the two
-  # can't drift apart.
+  # subgraph changed without a recompose). What they share is this evidence,
+  # not the verdict: Subgraphs wants every type AND field, Drift only the
+  # types — a schema that lost a field is not a candidate to run against, but
+  # is exactly the one Drift has to recognize to report the loss.
   module Schemas
     class << self
       # Every named GraphQL::Schema in the process. An anonymous one is

data/lib/graph_weaver/tasks.rb

@@ -24,6 +24,20 @@
 #      rake graph_weaver:cassettes:check       # fail if a recording no longer casts
 require_relative "../graph_weaver"
 
+module GraphWeaver
+  # helpers the rake tasks share; not part of the library's API
+  module Tasks
+    # The composed supergraph a federation task reads: SUPERGRAPH=, else the
+    # conventional dump when that is what it is. Aborts naming the task, so
+    # the message says the command to retype.
+    def self.supergraph!(task)
+      ENV["SUPERGRAPH"] || GraphWeaver::SchemaLoader.locate_path ||
+        abort("pass the composed supergraph: rake graph_weaver:federation:#{task} " \
+          "SUPERGRAPH=supergraph.graphql")
+    end
+  end
+end
+
 namespace :graph_weaver do
   # In Rails, boot the app first — initializers register scalars/enums/
   # helpers and they're baked into generated source. Rails defines
@@ -123,12 +137,7 @@ namespace :graph_weaver do
     task diff: :loaded do
       require "graph_weaver/federation"
 
-      supergraph = ENV["SUPERGRAPH"] || GraphWeaver::SchemaLoader.locate_path
-      unless supergraph
-        abort "pass the composed supergraph: rake graph_weaver:federation:diff " \
-          "SUPERGRAPH=supergraph.graphql"
-      end
-
+      supergraph = GraphWeaver::Tasks.supergraph!("diff")
       drift = GraphWeaver::Federation::Drift.new(supergraph:)
       puts drift.report
 
@@ -152,11 +161,7 @@ namespace :graph_weaver do
     task subgraphs: :loaded do
       require "graph_weaver/testing"
 
-      supergraph = ENV["SUPERGRAPH"] || GraphWeaver::SchemaLoader.locate_path
-      unless supergraph
-        abort "pass the composed supergraph: rake graph_weaver:federation:subgraphs " \
-          "SUPERGRAPH=supergraph.graphql"
-      end
+      supergraph = GraphWeaver::Tasks.supergraph!("subgraphs")
 
       # Testing::Router derives this map itself; this is for reading what
       # detection sees when it refuses, and for committing the map instead.
@@ -191,14 +196,8 @@ namespace :graph_weaver do
     task coverage: :loaded do
       require "graph_weaver/testing"
 
-      supergraph = ENV["SUPERGRAPH"] || GraphWeaver::SchemaLoader.locate_path
-      unless supergraph
-        abort "pass the composed supergraph: rake graph_weaver:federation:coverage " \
-          "SUPERGRAPH=supergraph.graphql"
-      end
-
       puts GraphWeaver::Testing::Coverage.new(
-        supergraph:,
+        supergraph: GraphWeaver::Tasks.supergraph!("coverage"),
         queries: ENV["QUERIES"] || GraphWeaver.queries_paths,
       ).report
     rescue GraphWeaver::Error => e
@@ -227,7 +226,9 @@ namespace :graph_weaver do
         Object.const_get(name) if Object.const_defined?(name)
       end
 
-      dir = GraphWeaver::Testing.config.cassette_dir
+      # Testing.cassette_dir, not config.cassette_dir: the configured path is
+      # relative by default and rake runs from wherever it runs from
+      dir = GraphWeaver::Testing.cassette_dir
       checks = Dir[File.join(dir, "*.yml")].sort.map do |path|
         GraphWeaver::Testing::Cassette.new(path).check(modules)
       end
@@ -256,8 +257,10 @@ namespace :graph_weaver do
     task anonymize: :environment do
       require "graph_weaver/testing"
 
-      schema = GraphWeaver::SchemaLoader.load(GraphWeaver.schema_path)
-      Dir[File.join(GraphWeaver::Testing.config.cassette_dir, "*.yml")].sort.each do |path|
+      # locate, not schema_path: the dump is whichever supported extension is
+      # actually on disk, and every sibling task asks the same way
+      schema = GraphWeaver::SchemaLoader.locate or abort "no schema dump at #{GraphWeaver.schema_path}"
+      Dir[File.join(GraphWeaver::Testing.cassette_dir, "*.yml")].sort.each do |path|
         GraphWeaver::Testing::Cassette.new(path).anonymize!(schema:)
         puts "anonymized #{path}"
       end