ecoportal-api-graphql 2.2.1 → 3.0.0

data/lib/ecoportal/api/graphql/model/template/node.rb

@@ -0,0 +1,78 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Shared behaviour for every mutable node in the editable template tree (Stage,
+          # Section, Field, Option, Force, Binding, Helper). A node is either:
+          #
+          #   * LOADED — `id` is a real server id, carried in from `Read.call`. `snapshot`
+          #     freezes the mutable attributes as they were at load time, so `#dirty?` /
+          #     `#changed_attributes` can diff "now" against "as loaded" later.
+          #   * NEW — `id` is nil; the node was created in memory (`Stage#add_section`, etc.)
+          #     and has no server counterpart yet. `#ref` mints a client-chosen `placeholderId`
+          #     the first time it is asked (deterministic, `"ph_<prefix>_<n>"`, matching the
+          #     scheme `Builder::TemplateBuilder`/`Diff::CommandSynthesizer` already use,
+          #     counter owned by the root `Instance` so two loaded templates never share
+          #     counters) and memoises it — every command in the same `#as_commands` batch
+          #     that addresses this node reuses the SAME token.
+          #
+          # `#ref` is the ONE thing every command-emission method should call to address a
+          # node — never `id` directly — because it transparently upgrades from placeholder to
+          # real id the moment `StagedExecutor` resolves this node against a live re-read
+          # (`#resolve!`), without the caller needing to know which phase it is in.
+          #
+          # Including class MUST define `PLACEHOLDER_PREFIX` (a short String, e.g. `'sec'`)
+          # and `#template` (the root `Instance`, which owns the placeholder counters).
+          module Node
+            attr_reader :id
+
+            def new?
+              id.nil?
+            end
+
+            def removed?
+              !!@removed
+            end
+
+            # Flags this node for a `remove*` command. Only meaningful for a LOADED node — a
+            # NEW node that is removed before ever being saved should simply be dropped from
+            # its parent collection instead (there is nothing server-side to remove yet).
+            def remove!
+              if new?
+                raise ArgumentError, "#{self.class}: cannot remove a node that was never saved " \
+                                     '(drop it from its parent collection instead)'
+              end
+
+              @removed = true
+            end
+
+            # The token every command that addresses this node must use: the real id once
+            # known, otherwise a memoised placeholder. `StagedExecutor#resolve!` is the only
+            # code that ever calls `#resolve!` — everything downstream just calls `#ref` again
+            # and transparently gets the real id from then on.
+            def ref
+              id || placeholder
+            end
+
+            def placeholder
+              @placeholder ||= template.next_placeholder(self.class::PLACEHOLDER_PREFIX)
+            end
+
+            # Called once a live re-read has matched this NEW node to its real server id.
+            # Raises if called on an already-resolved node with a DIFFERENT id (a resolver
+            # bug, not a transient condition) — silently overwriting a resolved id would hide
+            # a mismatched cross-check upstream.
+            def resolve!(real_id)
+              raise ArgumentError, "#{self.class}: resolve! requires a real id" if real_id.nil?
+              return if id == real_id
+              raise "#{self.class}: already resolved to #{id.inspect}, cannot re-resolve to #{real_id.inspect}" if id
+
+              @id = real_id
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/option.rb

@@ -0,0 +1,49 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One option of a Select field. Read-side field name is `name` (see the gem's own
+          # `selectField` fragment, `fragment/pages/common_page_union.rb`); write-side commands
+          # (`addSelectFieldOption`/`editSelectFieldOption`) name the same thing `label` — this
+          # class always uses `label`, mapping the read-side `name` -> `label` at load time
+          # (`Read.call`), so callers never see the read/write naming split.
+          class Option
+            include Node
+
+            PLACEHOLDER_PREFIX = 'opt'.freeze
+
+            attr_reader :template, :field
+            attr_accessor :label, :value, :weight
+
+            def initialize(template:, field:, id: nil, label: nil, value: nil, weight: nil)
+              @template = template
+              @field    = field
+              @id       = id
+              @label    = label
+              @value    = value
+              @weight   = weight
+              @snapshot = snapshot_attrs.freeze
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { label: label, value: value, weight: weight }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/read.rb

@@ -0,0 +1,164 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Live read for `Instance.load`/`StagedExecutor`'s between-phase re-reads.
+          #
+          # ***  PLATFORM FACT — workflow-first, DO NOT collapse onto `page.stages` alone  ***
+          #
+          # Ported verbatim (query shape) from a downstream script repo's
+          # template-fields read service, itself verified live 2026-08-01 and
+          # re-confirmed 2026-08-09: a command-bus-built template's PAGE projection can be
+          # EMPTY while its WORKFLOW carries the full structure (Workflow Builder / this gem's
+          # own `updatePageTemplate` writes workflow stage/section/field docs; the page
+          # projection does not always materialise from them), whereas a web-editor-built
+          # template DOES project page stages. Read `workflow { stages { sections } }` FIRST;
+          # fall back to the page projection only when the workflow yields nothing — never the
+          # other way round.
+          #
+          # SplitSection has NO `dataFields` — `leftDataFields`/`rightDataFields` only. Forces
+          # are read from `workflow.stages.forces` only (`18_template_editor_save_path.md`
+          # section A.1, `TemplateStageFields.forces`); the page projection carries no forces
+          # at all, so there is no fallback for that part of the read.
+          #
+          # `Helper`'s own five fields -- `id name filePath script contentB64` -- are LIVE-
+          # VERIFIED (not merely mirrored from the write side): a downstream script repo's
+          # template force-read case selects
+          # `helpers { id name filePath script contentB64 }` on exactly this same
+          # `forces` field, and that read has run live against pre_prod across 47 templates
+          # (that file's own header, lines 29-31/90). Use these five with confidence.
+          #
+          # UNVERIFIED against a live schema this session: any `Force` field beyond the
+          # `Helper` sub-fields cited above (e.g. a top-level `script` alongside
+          # `customScript`, or a plain `url`/`contentB64` on the force itself) -- cite before
+          # relying on anything not confirmed above.
+          module Read
+            STRUCTURE_QUERY = <<~GRAPHQL.freeze
+              query TemplateModelRead($id: ID!) {
+                currentOrganization {
+                  page(id: $id, showHiddenData: true) {
+                    __typename
+                    ... on BasicPage {
+                      id
+                      name
+                      patchVer
+                      workflow { stages { ...wfStage } }
+                      sections { ...sectionFields }
+                    }
+                    ... on PhasedPage {
+                      id
+                      name
+                      patchVer
+                      workflow { stages { ...wfStage } }
+                      stages { id name ordering sections { ...sectionFields } }
+                    }
+                  }
+                }
+              }
+
+              fragment wfStage on Stage {
+                id
+                name
+                ordering
+                sections { ...sectionFields }
+                forces {
+                  id
+                  name
+                  customScript
+                  url
+                  contentB64
+                  bindings { name referenceId }
+                  helpers { id name filePath script contentB64 }
+                }
+              }
+
+              fragment sectionFields on SectionUnion {
+                __typename
+                ... on ContentSection {
+                  id
+                  heading
+                  dataFields { ...tf }
+                }
+                ... on SplitSection {
+                  id
+                  heading
+                  leftHeading
+                  rightHeading
+                  leftDataFields { ...tf }
+                  rightDataFields { ...tf }
+                }
+              }
+
+              fragment tf on DataFieldUnion {
+                __typename
+                ... on DataFieldsInterface {
+                  id
+                  label
+                  description
+                  tooltip
+                  hidden
+                  required
+                }
+                ... on Select {
+                  options { id value name }
+                }
+              }
+            GRAPHQL
+
+            class << self
+              # @param client [Ecoportal::API::GraphQL] the top-level gem client (has
+              #   `#client` / `.http_client`, matching every other read in this gem).
+              # @param id [String] the template's page id.
+              # @return [Hash] the raw `page` doc (string keys, as the server sent it).
+              def call(client, id)
+                raw  = http(client).execute(STRUCTURE_QUERY, variables: { id: id })
+                page = raw.dig('data', 'currentOrganization', 'page')
+                raise "Template '#{id}' not readable as page" unless page
+
+                page
+              end
+
+              # Fields in document order, workflow-first, exactly `TemplateFieldsRead.fields`'s
+              # own semantics (kept as a module method so `StagedExecutor`'s re-read
+              # cross-checks can call it against a freshly re-fetched `page` doc without going
+              # through the whole `Instance` construction).
+              #
+              # @return [Array<Hash>] each entry carries stage_id/section_id/section_side
+              #   alongside the field's own doc, in document order.
+              def stages(page)
+                from_workflow = Array(page.dig('workflow', 'stages'))
+                return from_workflow unless from_workflow.empty?
+
+                fallback_stages(page)
+              end
+
+              private
+
+              # Accepts, in order of preference: the top-level `Ecoportal::API::GraphQL`
+              # object (`client.client.http_client`), the inner
+              # `Common::GraphQL::Client` directly (`client.http_client`), or a bare
+              # `#execute(query, variables:) -> Hash` duck (a spec double) as-is.
+              def http(client)
+                return client.client.http_client if client.respond_to?(:client) && client.client.respond_to?(:http_client)
+                return client.http_client if client.respond_to?(:http_client)
+
+                client
+              end
+
+              def fallback_stages(page)
+                case page['__typename']
+                when 'PhasedPage' then Array(page['stages'])
+                when 'BasicPage'
+                  [{ 'id' => nil, 'name' => nil, 'ordering' => 0, 'sections' => Array(page['sections']), 'forces' => [] }]
+                else
+                  []
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/section.rb

@@ -0,0 +1,82 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One section. `kind` is `:content` (single `fields` list) or `:split` (`left_fields`
+          # / `right_fields`, each independently addressable — a `SplitSection` has NO
+          # `dataFields` of its own, see `Read.call`'s header). `#fields` always returns the
+          # flattened, document-ordered list (left then right, for a split section) — the ONE
+          # place callers should iterate unless they specifically need a side.
+          class Section
+            include Node
+
+            PLACEHOLDER_PREFIX = 'sec'.freeze
+
+            attr_reader :template, :stage, :kind, :layout, :left_fields, :right_fields, :pending_move
+            attr_accessor :heading, :left_heading, :right_heading
+
+            def initialize(template:, stage:, id: nil, kind: :content, layout: nil,
+                           heading: nil, left_heading: nil, right_heading: nil)
+              @template      = template
+              @stage         = stage
+              @id            = id
+              @kind          = kind
+              @layout        = layout
+              @heading       = heading
+              @left_heading  = left_heading
+              @right_heading = right_heading
+              @left_fields   = []
+              @right_fields  = []
+              @pending_move  = nil
+              @snapshot      = snapshot_attrs.freeze
+            end
+
+            # Document-ordered fields. For a :content section this IS `left_fields`; for a
+            # :split section it is left-then-right (matches `Read.call`'s own document-order
+            # flattening, so `#fields` here and the loaded order agree).
+            def fields
+              kind == :split ? left_fields + right_fields : left_fields
+            end
+
+            def add_field(field_type:, label: nil, column: nil, side: nil, **kargs)
+              field = Field.new(template: template, section: self, stage: stage,
+                                field_type: field_type, label: label, column: column, **kargs)
+              (side == :right ? right_fields : left_fields) << field
+              field
+            end
+
+            # Records the intent to reposition this (existing) section relative to `anchor`
+            # (another Section) — emitted as ONE `reorderSection` command as a per-stage
+            # TRAILER (after every structural add/remove in the same stage), because the
+            # server rewrites EVERY sibling's weight on a reorder
+            # (`18_template_editor_save_path.md` section C.1) — running it before a same-batch
+            # `addStageSection` would have its effect immediately overwritten by the next
+            # section's own weight assignment.
+            def move(anchor:, position:)
+              raise ArgumentError, "position must be 'BEFORE' or 'AFTER'" unless %w[BEFORE AFTER].include?(position)
+
+              @pending_move = { anchor: anchor, position: position }
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { heading: heading, left_heading: left_heading, right_heading: right_heading }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/stage.rb

@@ -0,0 +1,49 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One workflow stage. `editStage`/`moveStage` exist server-side but are not wired to
+          # a mutable accessor here yet — out of scope for this pass (see the model's own
+          # design doc, "not yet implemented"); `name`/`ordering` are captured read-only for
+          # display and cross-checks.
+          class Stage
+            include Node
+
+            PLACEHOLDER_PREFIX = 'stg'.freeze
+
+            attr_reader :template, :sections, :forces, :name, :ordering
+
+            def initialize(template:, id: nil, name: nil, ordering: nil)
+              @template = template
+              @id       = id
+              @name     = name
+              @ordering = ordering
+              @sections = []
+              @forces   = []
+            end
+
+            def add_section(kind: :content, layout: nil, heading: nil, left_heading: nil, right_heading: nil)
+              section = Section.new(template: template, stage: self, kind: kind, layout: layout,
+                                    heading: heading, left_heading: left_heading, right_heading: right_heading)
+              sections << section
+              section
+            end
+
+            def add_force(name: nil, custom_script: nil, url: nil, content_b64: nil)
+              force = Force.new(template: template, stage: self, name: name, custom_script: custom_script,
+                                url: url, content_b64: content_b64)
+              forces << force
+              force
+            end
+
+            # Every field across every (non-removed) section of this stage, document order.
+            def fields
+              sections.reject(&:removed?).flat_map(&:fields)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/staged_executor.rb

@@ -0,0 +1,236 @@
+require 'securerandom'
+
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Ports a downstream script repo's staged `-template-force-install` install (sections ->
+          # re-read -> fields+options -> re-read -> forces -> re-read -> helpers+bindings) into
+          # a GENERIC, four-phase executor that works for ANY `Instance`, any number of
+          # stages/sections/fields — not one template's shape. Each phase is built FRESH from
+          # the CURRENT tree (`CommandSynthesis`'s phase-scoped methods), so a node resolved by
+          # an earlier phase (`Node#resolve!`) is addressed by its real id — never its stale
+          # placeholder — the moment the next phase's commands are synthesised (`Node#ref`
+          # itself does the upgrade; nothing here has to rewrite a command hash by hand).
+          #
+          # Sends through `Builder::Template#update` (`updatePageTemplate`) — NEVER
+          # `executeWorkflowCommands` — per `18_template_editor_save_path.md` section D.4/B.3's
+          # own recommendation (the SAME safety invariants the template editor enforces should
+          # apply to bulk/automated writes). Every call carries a fresh `clientMutationId` for
+          # tracing/correlation ONLY — the server does NOT dedupe on it (confirmed: neither
+          # `UpdateForm` nor `ExecuteCommandsForm` reference it in
+          # `18_template_editor_save_path.md` section B).
+          class StagedExecutor
+            DEFAULT_CHUNK_SIZE = 200
+
+            PHASES = %i[stage_phase section_phase field_phase force_phase helper_binding_phase].freeze
+
+            # Placeholder prefixes that MUST already be resolved to real ids by the time this
+            # phase's commands are built — a leftover token here means an earlier phase's
+            # resolution silently failed to cover this node, and sending anyway would either
+            # get rejected server-side or (worse) silently misfire. See `#guard_resolved!`.
+            REQUIRES_RESOLVED = {
+              section_phase:        %w[stg],
+              field_phase:          %w[stg sec],
+              force_phase:          %w[stg],
+              helper_binding_phase: %w[stg sec frc fld]
+            }.freeze
+
+            Plan   = Struct.new(:stages, keyword_init: true)
+            Result = Struct.new(:ok, :patch_ver, :stages, :error, keyword_init: true)
+
+            def initialize(instance, client:, chunk_size: DEFAULT_CHUNK_SIZE)
+              @instance   = instance
+              @client     = client
+              @chunk_size = chunk_size
+            end
+
+            # SIMULATE — no call is made. Returns the plan every phase WOULD send: command
+            # counts, chunk sizes, and every placeholder token appearing in that phase (a
+            # caller can eyeball this before ever touching the server).
+            def plan
+              synth = CommandSynthesis.new(instance)
+              Plan.new(stages: PHASES.map { |phase| phase_plan(synth, phase) })
+            end
+
+            # EXECUTE — actually sends the staged batches. Raises ArgumentError up front if no
+            # client was given (a `simulate: false` call with no client is a caller mistake,
+            # not a runtime condition to swallow).
+            def execute!
+              raise ArgumentError, 'StagedExecutor#execute! requires a client (got nil)' if client.nil?
+
+              patch_ver = instance.patch_ver
+              report = []
+
+              PHASES.each do |phase|
+                outcome = execute_phase(phase, patch_ver)
+                report << outcome
+                return abort(report, outcome[:error]) unless outcome[:ok]
+
+                patch_ver = outcome[:patch_ver]
+              end
+
+              Result.new(ok: true, patch_ver: patch_ver, stages: report, error: nil)
+            end
+
+            private
+
+            attr_reader :instance, :client, :chunk_size
+
+            def phase_plan(synth, phase)
+              commands = synth.public_send(phase)
+              chunks   = CommandGrouper.chunk(commands, chunk_size)
+              { phase: phase, command_count: commands.size, chunk_sizes: chunks.map(&:size),
+                placeholders: CommandGrouper.tokens_in(commands) }
+            end
+
+            def execute_phase(phase, patch_ver)
+              commands = CommandSynthesis.new(instance).public_send(phase)
+              return { phase: phase, ok: true, patch_ver: patch_ver, sent: 0 } if commands.empty?
+
+              guard_resolved!(phase, commands)
+
+              chunks = CommandGrouper.chunk(commands, chunk_size)
+              chunks.each do |chunk|
+                response = send_chunk(chunk, patch_ver)
+                return { phase: phase, ok: false, patch_ver: patch_ver, error: response[:error] } unless response[:ok]
+
+                patch_ver = response[:patch_ver]
+              end
+
+              resolve_phase!(phase)
+              { phase: phase, ok: true, patch_ver: patch_ver, sent: commands.size }
+            end
+
+            def abort(report, error)
+              Result.new(ok: false, patch_ver: report.last[:patch_ver], stages: report, error: error)
+            end
+
+            # Refuses to send a batch that still references a placeholder an EARLIER phase
+            # should already have resolved — see `REQUIRES_RESOLVED`'s own doc.
+            def guard_resolved!(phase, commands)
+              prefixes = REQUIRES_RESOLVED[phase]
+              return if prefixes.nil? || prefixes.empty?
+
+              stale = CommandGrouper.tokens_in(commands).select { |tok| prefixes.any? { |p| tok.start_with?("ph_#{p}_") } }
+              return if stale.empty?
+
+              raise "StagedExecutor: refusing to send #{phase} — it still references " \
+                    "#{stale.size} unresolved placeholder(s) from an earlier phase: #{stale.join(', ')}. " \
+                    'An earlier phase\'s resolution step did not cover every new node it created.'
+            end
+
+            def send_chunk(chunk, patch_ver)
+              payload = builder.update(instance, commands: chunk, patch_ver: patch_ver,
+                                                  client_mutation_id: "tmpl-model-#{SecureRandom.hex(6)}")
+              return { ok: false, error: 'no payload returned' } if payload.nil?
+              return { ok: false, error: payload.error_doc } if payload.error?
+
+              { ok: true, patch_ver: payload.item.patchVer }
+            end
+
+            def builder
+              @builder ||= client.template
+            end
+
+            # --- between-phase resolution -------------------------------------------
+
+            def resolve_phase!(phase)
+              case phase
+              when :stage_phase then resolve_stages! if instance.stages.any?(&:new?)
+              when :section_phase then resolve_sections! if instance.sections.any?(&:new?)
+              when :field_phase then resolve_fields! if instance.fields.any?(&:new?)
+              when :force_phase then resolve_forces! if instance.forces.any?(&:new?)
+              end
+            end
+
+            def fresh_page
+              Read.call(client, instance.id)
+            end
+
+            def resolve_stages!
+              live = Read.stages(fresh_page)
+              resolve_new_children!(instance.stages, live, cross_check: :name, live_key: 'name', label: 'stage')
+            end
+
+            def resolve_sections!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, i|
+                live_sections = Array(live_stages.dig(i, 'sections'))
+                resolve_new_children!(stage.sections, live_sections, cross_check: :heading, live_key: 'heading', label: "stage[#{i}] section")
+              end
+            end
+
+            def resolve_fields!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, si|
+                stage.sections.each_with_index do |section, sci|
+                  live_section = live_stages.dig(si, 'sections', sci)
+                  resolve_section_fields!(section, live_section)
+                end
+              end
+            end
+
+            def resolve_section_fields!(section, live_section)
+              if section.kind == :split
+                resolve_new_children!(section.left_fields, Array(live_section&.dig('leftDataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'split left field')
+                resolve_new_children!(section.right_fields, Array(live_section&.dig('rightDataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'split right field')
+              else
+                resolve_new_children!(section.left_fields, Array(live_section&.dig('dataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'content field')
+              end
+            end
+
+            def resolve_forces!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, i|
+                live_forces = Array(live_stages.dig(i, 'forces'))
+                resolve_new_children!(stage.forces, live_forces, cross_check: :name, live_key: 'name', label: "stage[#{i}] force")
+              end
+            end
+
+            # Generic positional-plus-cross-check resolver: `nodes` is the CURRENT in-memory
+            # sibling list (loaded ones keep their relative order; new ones are appended, so
+            # `nodes.select(&:new?)` is exactly "the ones the last-sent batch just created, in
+            # creation order"). `live_docs` is the FRESH re-read of the SAME sibling collection.
+            #
+            #   count guard  — live count minus the pre-existing count must equal exactly the
+            #                  number of new nodes this batch created (never "roughly matches").
+            #   cross-check  — the new server docs are assumed appended at the tail, matched
+            #                  1:1 in creation order; when the node's own `cross_check`
+            #                  attribute is non-nil, it must equal the live doc's `live_key`
+            #                  value, or resolution raises rather than silently mis-mapping an
+            #                  id to the wrong node.
+            def resolve_new_children!(nodes, live_docs, cross_check:, live_key:, label:)
+              new_nodes = nodes.select(&:new?)
+              return if new_nodes.empty?
+
+              before_count = nodes.size - new_nodes.size
+              delta        = live_docs.size - before_count
+              if delta != new_nodes.size
+                raise "StagedExecutor: #{label} count guard failed -- expected #{new_nodes.size} new, " \
+                      "live delta is #{delta} (before=#{before_count}, live=#{live_docs.size})"
+              end
+
+              matched = live_docs.last(delta)
+              new_nodes.each_with_index do |node, idx|
+                live     = matched[idx]
+                expected = node.public_send(cross_check)
+                actual   = live[live_key]
+                if !expected.nil? && expected != actual
+                  raise "StagedExecutor: #{label} cross-check failed at position #{idx} -- " \
+                        "expected #{cross_check}=#{expected.inspect}, live #{live_key}=#{actual.inspect}"
+                end
+
+                node.resolve!(live['id'])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end