graph_weaver 0.7.0 → 0.7.2

data/examples/github/queries/stargazers.graphql

@@ -0,0 +1,22 @@
+query($owner: String!, $name: String!, $first: Int!) {
+  repository(owner: $owner, name: $name) {
+    id
+    nameWithOwner
+    stargazerCount
+    stargazers(first: $first, orderBy: { field: STARRED_AT, direction: DESC }) {
+      edges {
+        starredAt
+        node {
+          login
+          name
+          repositories(first: 2, orderBy: { field: STARGAZERS, direction: DESC }) {
+            nodes {
+              nameWithOwner
+              stargazerCount
+            }
+          }
+        }
+      }
+    }
+  }
+}

data/examples/github/queries/starred.graphql

@@ -0,0 +1,11 @@
+query($login: String!, $first: Int!) {
+  user(login: $login) {
+    starredRepositories(first: $first, orderBy: { field: STARRED_AT, direction: DESC }) {
+      totalCount
+      nodes {
+        nameWithOwner
+        stargazerCount
+      }
+    }
+  }
+}

data/examples/github/run.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# typed: false
+# frozen_string_literal: true
+
+# Star graph_weaver ⭐ (thanks!), then meet your fellow stargazers —
+# who they are, their biggest repos, and what else they've starred:
+#
+#      examples/github/run.rb
+require_relative "setup"
+
+# the checked-in typed modules (regenerate: examples/github/generate.rb)
+Dir[File.join(__dir__, "generated", "*.rb")].sort.each { |file| require file }
+
+OWNER = "dpep"
+NAME = "graph_weaver"
+
+repo = StargazersQuery.execute!(owner: OWNER, name: NAME, first: 1).repository
+abort "repository not found" unless repo
+
+# join the club (idempotent — starring twice is fine)
+starrable = StarMutation.execute!(id: repo.id).add_star&.starrable
+puts "⭐ starred #{repo.name_with_owner} — #{starrable&.stargazer_count} star(s). Thanks!"
+
+# refreshed, so the list includes you
+repo = StargazersQuery.execute!(owner: OWNER, name: NAME, first: 10).repository
+
+puts "\nThe stargazers:"
+repo.stargazers.edges&.each do |edge|
+  gazer = edge&.node
+  next unless gazer
+
+  who = gazer.name ? "#{gazer.login} (#{gazer.name})" : gazer.login
+  top = gazer.repositories.nodes&.compact&.map { |r| "#{r.name_with_owner} ⭐#{r.stargazer_count}" }
+  puts "  #{who} — starred #{edge.starred_at&.strftime("%Y-%m-%d")}"
+  puts "    top repos: #{top.join(", ")}" if top&.any?
+
+  # drill down: what else have they starred lately?
+  starred = StarredQuery.execute!(login: gazer.login, first: 3).user&.starred_repositories
+  next unless starred
+
+  also = starred.nodes&.compact&.reject { |r| r.name_with_owner == repo.name_with_owner }
+  puts "    also starred (#{starred.total_count} total): #{also.map(&:name_with_owner).join(", ")}" if also&.any?
+end

data/examples/github/setup.rb

@@ -0,0 +1,18 @@
+# typed: false
+# frozen_string_literal: true
+
+# Shared wiring for the GitHub example: auth and the client.
+require_relative "../../lib/graph_weaver"
+
+token = ENV["GITHUB_TOKEN"] || `gh auth token 2>/dev/null`.strip
+abort "need a token: `gh auth login`, or GITHUB_TOKEN=..." if token.empty?
+
+GraphWeaver.client = GraphWeaver.new(
+  "https://api.github.com/graphql",
+  auth: token,
+  # used by generate.rb (and any dynamic parse): the first introspection
+  # of GitHub's large schema dumps here — gitignored, a few seconds once,
+  # instant after. run.rb's checked-in generated modules never introspect,
+  # so running it alone won't create this file.
+  cache: File.join(__dir__, "schema.json"),
+)

data/examples/rick_and_morty.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# typed: false
+# frozen_string_literal: true
+
+# One notch up from countries.rb: filtered search, pagination, an aliased
+# field, and a block-built type helper — against the Rick and Morty API
+# (free, no auth, wubba lubba dub dub):
+#
+#      examples/rick_and_morty.rb [NAME]
+#      examples/rick_and_morty.rb morty
+require_relative "../lib/graph_weaver"
+
+api = GraphWeaver.new("https://rickandmortyapi.com/graphql")
+
+# decorate every Character struct generated from this type — derived values
+# live as methods, the wire data stays honest
+GraphWeaver.extend_type("Character") do
+  def emoji
+    { "Alive" => "🟢", "Dead" => "💀" }.fetch(status, "❓")
+  end
+end
+
+CharacterQuery = api.parse(<<~GRAPHQL)
+  query($name: String, $page: Int) {
+    characters(page: $page, filter: { name: $name }) {
+      # a GraphQL alias names the prop: `info.next_page`, not `info.next`
+      info { count pages nextPage: next }
+      results {
+        name
+        status
+        species
+        origin { name }
+        episode { name }
+      }
+    }
+  }
+GRAPHQL
+
+name = ARGV.first || "smith"
+page = 1
+total = nil
+
+loop do
+  characters = CharacterQuery.execute!(name:, page:).characters
+  abort "no characters match #{name.inspect}" if characters&.results.to_a.empty?
+
+  total ||= characters.info&.count
+  characters.results.compact.each do |character|
+    debut = character.episode.compact.first&.name
+    puts "#{character.emoji} #{character.name} — #{character.species} from #{character.origin&.name}, debuted in #{debut.inspect}"
+  end
+
+  page = characters.info&.next_page
+  break unless page
+end
+
+puts "\n#{total} character(s) matched #{name.inspect}"

data/graph_weaver.gemspec

@@ -10,9 +10,14 @@ Gem::Specification.new do |s|
   # CLAUDE.md/PLAN.md/REVIEW.md/NOTES.md/DECISIONS.md are written for whoever
   # works on the gem, not whoever installs it — and REVIEW.md carries examples
   # from before the API it describes was rewritten
-  s.files       = `git ls-files * ':!:spec' ':!:sorbet' ':!:bin' ':!:examples' \
+  # examples/ ships (small plain text) so the README's links to it resolve for
+  # someone who only has the installed gem, not a checkout
+  # CHANGELOG.md doesn't (259 KB, ~16% of the package) — changelog_uri below
+  # points at the GitHub copy instead
+  s.files       = `git ls-files * ':!:spec' ':!:sorbet' ':!:bin' \
                      ':!:CLAUDE.md' ':!:PLAN.md' ':!:REVIEW.md' ':!:NOTES.md' \
-                     ':!:DECISIONS.md' ':!:Makefile' ':!:design'`.split("\n") + [".yardopts"]
+                     ':!:DECISIONS.md' ':!:CHANGELOG.md' ':!:Makefile' ':!:design' \
+                     ':!:research'`.split("\n") + [".yardopts"]
   s.homepage    = "https://github.com/dpep/graph_weaver"
   s.license     = "MIT"
   s.name        = "graph_weaver"
@@ -22,8 +27,12 @@ Gem::Specification.new do |s|
 
   s.metadata = {
     "bug_tracker_uri" => "#{s.homepage}/issues",
-    "changelog_uri" => "#{s.homepage}/blob/main/CHANGELOG.md",
+    # pinned to the release tag, not main — CHANGELOG.md isn't packaged, and
+    # main drifts ahead of whatever version this metadata shipped with
+    "changelog_uri" => "#{s.homepage}/blob/v#{s.version}/CHANGELOG.md",
     "documentation_uri" => "#{s.homepage}/tree/main/docs",
+    # no separate homepage_uri: identical to s.homepage, and `gem build` warns
+    # that rubygems.org only shows one of two metadata keys with the same uri
     "rubygems_mfa_required" => "true",
     "source_code_uri" => s.homepage,
   }

data/lib/graph_weaver/client.rb

@@ -77,6 +77,10 @@ class GraphWeaver::Client
       # a live schema class doubles as an in-process transport; a loaded
       # dump has no resolvers, so it is type information only
       @schema = source.is_a?(Module) ? source : GraphWeaver::SchemaLoader.load(source)
+      # A supergraph's routing table lives in the file, not in the loaded
+      # schema, so the path is the only thing that can name one later. Told
+      # from SDL by its extension, as SchemaLoader tells it.
+      @schema_source = source if !source.is_a?(Module) && GraphWeaver::SchemaLoader.dump_path?(source)
 
       if context && !(source.is_a?(Module) && transport.nil?)
         # nothing would ever read it — a dump has no resolvers, and an
@@ -122,12 +126,27 @@ class GraphWeaver::Client
   # schema-dump clients (type information only).
   attr_reader :transport
 
+  # The dump this client's schema was read from, or nil for a url, a schema
+  # class, or inline SDL. What a graph named by this client is named by.
+  attr_reader :schema_source
+
   # transport, when this client must be able to execute
   private def transport!
     transport or raise GraphWeaver::Error,
       "this client has no transport (built from a schema dump) — pass a url or transport:"
   end
 
+  # How long a failed introspection answers for the threads behind it. The
+  # lock makes a cold schema one round trip at a time, so against a hung
+  # upstream every queued thread used to pay its own read_timeout in turn —
+  # 8 threads at the 30s default is four minutes of occupied worker, and the
+  # next wave paid it again. A second is enough to collapse a wave and the
+  # retry right behind it, and short enough that an upstream which comes back
+  # is tried again on the next request. Deliberately not a circuit breaker:
+  # nothing here counts failures or stays open.
+  FAILURE_TTL = 1.0
+  private_constant :FAILURE_TTL
+
   # The schema, introspecting through the transport on first use (cached
   # per the client's cache:/ttl:) unless one was given up front.
   #
@@ -136,7 +155,17 @@ class GraphWeaver::Client
   # in-flight thread, each of them also writing the cache file.
   def schema
     @schema_lock.synchronize do
-      @schema ||= GraphWeaver::SchemaLoader.introspect(transport!, cache: @cache, ttl: @ttl)
+      next @schema if @schema
+      raise @schema_error if @schema_error && Process.clock_gettime(Process::CLOCK_MONOTONIC) < @schema_error_until
+
+      begin
+        @schema_error = nil
+        @schema = GraphWeaver::SchemaLoader.introspect(transport!, cache: @cache, ttl: @ttl)
+      rescue GraphWeaver::Error => e
+        @schema_error = e
+        @schema_error_until = Process.clock_gettime(Process::CLOCK_MONOTONIC) + FAILURE_TTL
+        raise
+      end
     end
   end
 

data/lib/graph_weaver/codegen/emit.rb

@@ -456,22 +456,16 @@ class GraphWeaver::Codegen
     end
 
     def emit_execute(out, variables)
-      # client/client= carry no per-query types, so they live in the gem
-      out << "  # client / client= — see GraphWeaver::QueryModule"
+      # client carries no per-query types, so it lives in the gem
+      out << "  # client — see GraphWeaver::QueryModule"
       out << "  extend GraphWeaver::QueryModule"
       if @graph_name
         out << ""
-        out << "  # the graph this module was generated from — what a test mode builds"
-        out << "  # its stand-in client from"
+        out << "  # the graph this module was generated from — whose client it runs"
+        out << "  # against, and what a test mode builds its stand-in from"
         out << "  GRAPH = T.let(#{@graph_name.inspect}, Symbol)"
-        out << "  private_constant :GRAPH"
-      end
-      if @client_const
-        out << ""
-        out << "  # the baked default client, resolved on first use"
-        out << "  DEFAULT_CLIENT = T.let(-> { #{@client_const} }, T.proc.returns(T.untyped))"
         # QueryModule reads it with const_get, which privacy doesn't block
-        out << "  private_constant :DEFAULT_CLIENT"
+        out << "  private_constant :GRAPH"
       end
       out << ""
 

data/lib/graph_weaver/codegen.rb

@@ -59,15 +59,10 @@ class GraphWeaver::Codegen
 
   attr_reader :name
 
-  # A client is anything responding to `execute(query, variables:)`
-  # whose result `to_h`s into {"data" => ..., "errors" => ...} — a
-  # GraphWeaver::Client, a transport, a schema class, a fake.
-  #
-  # client: (a constant, or its name as a string) becomes the generated
-  # module's baked default; when omitted, generated code falls back to
-  # the app default (GraphWeaver.client=). graph_name: is the graph the
-  # module belongs to, baked in so a test mode can build its stand-in from
-  # the right schema. name: is the module the file
+  # graph_name: is the graph the module belongs to, baked in because it is
+  # the one thing a module can't be told at call time: it decides which
+  # client the module runs against (GraphWeaver::QueryModule) and which
+  # schema a test mode fabricates from. name: is the module the file
   # defines, defaulting to the operation's own name; default_name: is
   # parse's container-scoped fallback (file generation stays strict — a
   # checked-in file deserves a deliberate name). types_namespace: is the shared-types workflow (see
@@ -78,7 +73,7 @@ class GraphWeaver::Codegen
   # whole-union field spread as one of them resolves to a canonical type in the
   # shared module (see used_union_names). path: is the file the query was read
   # from, named alongside line and column in validation errors.
-  def initialize(schema:, query:, name: nil, client: nil, default_name: nil,
+  def initialize(schema:, query:, name: nil, default_name: nil,
     types_namespace: nil, hoistable_unions: nil, path: nil, module_name: nil,
     graph_name: nil, registry: GraphWeaver::Codegen.registry)
     renamed!(module_name)
@@ -96,28 +91,10 @@ class GraphWeaver::Codegen
     @used_unions = []
     # scalars this generation had no registration for (see report_untyped_scalars)
     @untyped_scalars = []
-    @client_const = CLIENT_CONST.call(client)
-    # the graph this module belongs to, baked in beside the client: a test
-    # mode builds its stand-in from the module's own schema, and only the
-    # module can say whose that is (GraphWeaver::Internal::TestClients).
-    # A Symbol, as GraphWeaver.graph makes it — the name is the identity.
+    # the graph this module belongs to: its client and, under a test mode,
+    # its stand-in are both read off it, and only the module can say whose
+    # it is. A Symbol, as GraphWeaver.graph makes it — the name is the identity.
     @graph_name = graph_name&.to_sym
-
-    if client && @client_const.nil?
-      # a live object can't be spelled in generated source — parse can
-      # set one via the module's writer, but file generation cannot
-      raise ArgumentError, "client: must be a named constant or String (got #{client.inspect}) — " \
-        "put the object in a constant and name it, client: \"MyApi::CLIENT\"; pass live objects to parse"
-    end
-    # The String is written into the module verbatim, so anything that isn't a
-    # constant path emits source that doesn't parse. A url is the way to get
-    # here — it is where the endpoint is spelled everywhere else — so the fix
-    # names the value that was passed.
-    if @client_const && !@client_const.match?(CONSTANT_NAME)
-      raise ArgumentError, "client: #{@client_const.inspect} isn't a constant — generated source " \
-        "spells this name, so it has to be one: CLIENT = GraphWeaver.new(#{@client_const.inspect}), " \
-        "then client \"CLIENT\""
-    end
   end
 
   # 0.5 spelled it module_name:, in two of the three doors. One knob, one
@@ -129,33 +106,19 @@ class GraphWeaver::Codegen
   end
   private :renamed!
 
-  # The constant name a client can be referenced by in generated
-  # source — nil when it can't be (live objects, anonymous modules).
-  # A lambda rather than a method: both `parse` and `initialize` need it,
-  # from the class and from an instance.
-  CLIENT_CONST = lambda do |client|
-    case client
-    when String then client
-    when Module then client.name
-    end
-  end
-  private_constant :CLIENT_CONST
-
   # one-step shorthand
-  def self.generate(schema:, query:, name: nil, client: nil, path: nil, module_name: nil)
-    new(schema:, query:, name:, client:, path:, module_name:).generate
+  def self.generate(schema:, query:, name: nil, path: nil, module_name: nil)
+    new(schema:, query:, name:, path:, module_name:).generate
   end
 
   # Development convenience: generate + eval in one step, no build
   # artifact or checked-in file. Same runtime semantics as the generated
   # file, but invisible to srb tc — use the build step for static typing.
-  # Evaluates into an anonymous container, so no global constants leak;
-  # client: additionally accepts a live object (set via .client=).
+  # Evaluates into an anonymous container, so no global constants leak.
+  # client: is the client the parsed module runs against — it has no graph to
+  # read one off — and a per-call `client:` still wins over it.
   def self.parse(schema:, query:, name: nil, client: nil, path: nil, module_name: nil, graph_name: nil)
-    client_const = CLIENT_CONST.call(client)
-
-    codegen = new(schema:, query:, name:, client: client_const, path:, module_name:, graph_name:,
-      default_name: "Query")
+    codegen = new(schema:, query:, name:, path:, module_name:, graph_name:, default_name: "Query")
     source = codegen.generate
 
     container = Module.new
@@ -167,9 +130,10 @@ class GraphWeaver::Codegen
     container.module_eval(source, "(graph_weaver)", 1)
     mod = container.const_get(codegen.name)
     GraphWeaver::Internal::Log.log(:debug) { "parsed #{codegen.name} (dynamic module, #{source.bytesize} bytes)" }
-    # live objects (or anonymous modules) can't be referenced from
-    # generated source — set them via the module's writer instead
-    mod.client = client if client && client_const.nil?
+    # a parsed module generates no file, so it has no graph to read a client
+    # off — client: binds one, whatever kind of object it is. The writer is
+    # private: parsing is the only thing that may bind one.
+    mod.send(:client=, client) if client
     mod
   end
 
@@ -1147,7 +1111,11 @@ class GraphWeaver::Codegen
   # about. Dispatch reads __typename, so the query must select it; for
   # interfaces the interface-level fields gather into every member.
   def union_members(type, selections)
-    raise ArgumentError, typename_refusal(type, selections) unless dispatchable_typename?(type, selections)
+    unless dispatchable_typename?(type, selections)
+      # a refusal about the query, like its siblings: branded and path-named,
+      # so generate! can collect it and rake names the file
+      raise GraphWeaver::Error, "#{@path ? "#{@path}: " : ""}#{typename_refusal(type, selections)}"
+    end
 
     selected_members(type, selections).sort_by(&:graphql_name).to_h do |possible|
       [possible.graphql_name, object_node(possible, selections, camelize(possible.graphql_name))]

data/lib/graph_weaver/context_seam.rb

@@ -0,0 +1,54 @@
+# typed: true
+# frozen_string_literal: true
+
+require "monitor"
+
+module GraphWeaver
+  # The settable GraphQL context, and the lock that guards it. {InProcess}
+  # and {Testing::Router} include it; so can any client of your own that
+  # wants the header seam.
+  #
+  # A `context:` proc is answered from one request's headers, which means
+  # assigning the client's context for the length of that dispatch — shared
+  # state, on the client. So the lock lives here, beside the field, rather
+  # than on whichever wrapper happens to be dispatching:
+  # {Testing::Endpoint} is built per request by `graphql: :wire`, and two of
+  # them over one client used to share nothing.
+  module ContextSeam
+    # the context handed to every query this client runs
+    attr_reader :context
+
+    def context=(value)
+      # Callability is settled by the field's owner, never by the
+      # per-request swap below — a resolved hash installed for one dispatch
+      # must not tell a concurrent one that this client has no seam.
+      @context_callable = value.respond_to?(:call)
+      @context = value
+    end
+
+    # Run the block with the context this request's headers mean — what
+    # {Testing::Endpoint} calls. A callable context is resolved and put back
+    # under the lock, so one request's identity can't leak into another's. A
+    # plain context has nothing to guard, so it is served concurrently.
+    def with_request_context(headers)
+      return yield unless @context_callable
+
+      @context_lock.synchronize do
+        seam = @context
+        @context = seam.call(headers)
+        begin
+          yield
+        ensure
+          @context = seam
+        end
+      end
+    end
+
+    # Call from your initializer. A Monitor rather than a Mutex: a resolver
+    # may re-enter the app.
+    private def init_context_seam(context)
+      @context_lock = Monitor.new
+      self.context = context
+    end
+  end
+end

data/lib/graph_weaver/errors.rb

@@ -5,6 +5,7 @@ require "sorbet-runtime"
 require "time" # Time.httpdate, for Retry-After
 
 require_relative "inflect"
+require_relative "internal/endpoint"
 require_relative "internal/headers"
 require_relative "logging"
 
@@ -125,15 +126,26 @@ module GraphWeaver
     attr_reader :url
 
     sig do
-      params(status: Integer, body: T.untyped, headers: T::Hash[String, String], url: T.nilable(String)).void
+      params(
+        status: Integer,
+        body: T.untyped,
+        headers: T::Hash[String, String],
+        url: T.nilable(String),
+        detail: T.nilable(String),
+      ).void
     end
-    def initialize(status:, body: nil, headers: {}, url: nil)
+    def initialize(status:, body: nil, headers: {}, url: nil, detail: nil)
       @status = status
       @body = body
       @url = url
       @headers = T.let(GraphWeaver::Internal::Headers.wrap(headers), T::Hash[String, String])
-      snippet = body.to_s.empty? ? "" : ": #{body.to_s[0, 500]}"
-      super("HTTP #{status}#{snippet}#{" — #{hint}" if hint}#{" — POST #{url}" if url}")
+      # A message never carries a body. `detail` is what WE say went wrong; the
+      # bytes the server sent stay on #body, the way #to_h already keeps the
+      # headers off — an error page that echoes the request (Rails' own dev
+      # page, many proxies) carries the caller's variables and our own
+      # Authorization header, and every raised error writes its message to the
+      # log at warn.
+      super("HTTP #{status}#{" — #{detail}" if detail}#{" — #{hint}" if hint}#{" — POST #{url}" if url}")
     end
 
     # What to do about this status, where the status says it. A redirect is
@@ -145,26 +157,22 @@ module GraphWeaver
     sig { returns(T.nilable(String)) }
     def hint
       if REDIRECTS.include?(status)
+        # the destination is a url the SERVER chose — said the way we say our
+        # own, and without the framing a header value could smuggle in
         location = headers["location"]
+        location &&= GraphWeaver::Internal::Redact.tag(GraphWeaver::Internal::Endpoint.safe(location))
         "redirects are not followed#{" — point the client at #{location}" if location}"
       elsif [401, 403].include?(status)
         "the server rejected the credentials — check auth: (the token, and its scopes)"
       end
     end
 
-    # Seconds to wait per the server's Retry-After, which is either a
-    # delay in seconds or an HTTP-date. nil when absent or unparseable;
-    # negative dates (already past) clamp to 0. See RFC 9110 §10.2.3.
+    # Seconds to wait per the server's Retry-After, or nil. Parsed off the
+    # headers, which is also where a returned envelope reads it — so one rule
+    # answers a rate limit however it arrived.
     sig { returns(T.nilable(Float)) }
     def retry_after
-      value = headers["retry-after"]&.strip
-      return if value.nil? || value.empty?
-      return value.to_f if value.match?(/\A\d+(\.\d+)?\z/)
-
-      seconds = Time.httpdate(value) - Time.now
-      [seconds, 0.0].max
-    rescue ArgumentError
-      nil
+      GraphWeaver::Internal::Headers.wrap(headers).retry_after
     end
 
     # True when the server said "you're going too fast" — 429, or the

data/lib/graph_weaver/federation.rb

@@ -142,7 +142,10 @@ module GraphWeaver
       def report
         return "#{@source} names no subgraphs" if @table.subgraphs.empty?
 
-        [headline, *section(STALE, @stale), *shape_section, *section(UNCOMPOSED, @uncomposed),
+        # the scope caveat rides with the verdict that overclaims without it;
+        # a drift report is already telling you to recompose
+        [headline, *(NOT_COMPARED unless drift? || vacuous?),
+          *section(STALE, @stale), *shape_section, *section(UNCOMPOSED, @uncomposed),
           *skipped_section, *faked_section].join("\n")
       end
       alias to_s report
@@ -154,6 +157,12 @@ module GraphWeaver
 
       private
 
+      # A pass says the supergraph still describes the fields these schemas
+      # have — not that the next composition would succeed. Both categories
+      # below are composition's business, and this reads neither.
+      NOT_COMPARED = "not compared: @key (added, removed, or made unresolvable), and one field " \
+        "two subgraphs define without @shareable — recompose to catch those"
+
       STALE = "stale — the supergraph carries these, no schema here defines them (recompose):"
       SHAPE = "shape — both carry these, with different types (recompose):"
       UNCOMPOSED = "not composed in — a schema here defines these, the supergraph doesn't carry them:"
@@ -298,7 +307,7 @@ module GraphWeaver
         verdict =
           if counts.any? then counts.join(", ")
           elsif vacuous? then "compared against nothing here"
-          else "matches the schemas here"
+          else "matches the schemas here, field for field and type for type"
           end
         "#{@source}: #{verdict} " \
           "(checked #{@checked.size} of #{@table.subgraphs.size} subgraphs)"