igniter 0.5.0 → 0.5.1

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/expansion_planner.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # Analyses network topology + episodic memory to produce an ExpansionPlan.
     #
     # Two modes of operation:
@@ -10,42 +11,43 @@ module Igniter
     #
     # Rule-based heuristics (applied in order):
     # 1. Retire nodes marked unhealthy in the topology.
-    # 2. Spawn a new node for each required role absent from the topology.
+    # 2. Spawn a new node for each required capability query absent from the topology.
     # 3. Annotate the rationale when recent replication failures exceed the threshold.
-    # 4. Honour :scale_signal episodes (content: "scale_out:<role>").
+    # 4. Honour :scale_signal episodes (content: "scale_out:<capability>[+<capability>]").
     #
     # LLM mode receives topology snapshot + recent episodes and expects the
     # executor to return { actions: [...], rationale: "..." }.
     #
     # @example Rule-based
     #   topology = NetworkTopology.new
-    #   topology.register(node_id: "x", host: "10.0.0.1", role: :worker)
+    #   topology.register(node_id: "x", host: "10.0.0.1", capabilities: [:local_llm])
     #
     #   planner = ExpansionPlanner.new(
-    #     topology:       topology,
-    #     required_roles: [:worker, :coordinator],
-    #     host_pool:      ["10.0.0.2"]
+    #     topology:              topology,
+    #     required_capabilities: [[:local_llm], %i[container_runtime local_llm]],
+    #     host_pool:             ["10.0.0.2"]
     #   )
     #   plan = planner.plan
-    #   # plan.actions => [{ action: :replicate_role, role: :coordinator, host: "10.0.0.2" }]
+    #   # plan.actions => [{ action: :replicate_capabilities, query: { all_of: [:container_runtime, :local_llm] }, host: "10.0.0.2" }]
     class ExpansionPlanner
       DEFAULT_FAILURE_THRESHOLD = 3
 
       # @param topology          [NetworkTopology]     current node topology
       # @param memory            [AgentMemory, nil]    episodic memory (optional)
-      # @param required_roles    [Array<Symbol>]       roles that must always be present
+      # @param required_capabilities [Array<CapabilityQuery, Array<Symbol>, Hash, Symbol>]
+      #   capability slices that must always be present
       # @param failure_threshold [Integer]             replication failures before warning
       # @param host_pool         [Array<String>]       candidate hosts for new nodes
       # @param llm               [#call, nil]          optional LLM executor
-      def initialize(topology:, memory: nil, required_roles: [],
+      def initialize(topology:, memory: nil, required_capabilities: [],
                      failure_threshold: DEFAULT_FAILURE_THRESHOLD,
                      host_pool: [], llm: nil)
-        @topology          = topology
-        @memory            = memory
-        @required_roles    = Array(required_roles).map(&:to_sym)
-        @failure_threshold = failure_threshold
-        @host_pool         = host_pool.dup
-        @llm               = llm
+        @topology              = topology
+        @memory                = memory
+        @required_capabilities = Array(required_capabilities).map { |query| CapabilityQuery.normalize(query) }
+        @failure_threshold     = failure_threshold
+        @host_pool             = host_pool.dup
+        @llm                   = llm
       end
 
       # Produce an ExpansionPlan.
@@ -62,7 +64,7 @@ module Igniter
         rationale = []
 
         retire_unhealthy(actions, rationale)
-        ensure_required_roles(actions, rationale)
+        ensure_required_capabilities(actions, rationale)
         check_failure_signal(rationale)
         apply_scale_signals(actions, rationale)
 
@@ -77,16 +79,16 @@ module Igniter
         end
       end
 
-      def ensure_required_roles(actions, rationale)
-        @required_roles.each do |role|
-          next unless @topology.needs_role?(role)
+      def ensure_required_capabilities(actions, rationale)
+        @required_capabilities.each do |query|
+          next unless @topology.needs_capability_query?(query)
 
           host = next_available_host
           if host
-            actions   << { action: :replicate_role, role: role, host: host }
-            rationale << "role :#{role} absent; targeting #{host}"
+            actions   << { action: :replicate_capabilities, query: query.to_h, host: host }
+            rationale << "capability query #{query.label.inspect} absent; targeting #{host}"
           else
-            rationale << "role :#{role} absent but no available host in pool"
+            rationale << "capability query #{query.label.inspect} absent but no available host in pool"
           end
         end
       end
@@ -105,14 +107,14 @@ module Igniter
         return unless @memory
 
         @memory.recent(last: 10, type: :scale_signal).each do |ep|
-          m = ep.content.to_s.match(/\Ascale_out:(\w+)\z/)
+          m = ep.content.to_s.match(/\Ascale_out:([@\w+,-]+)\z/)
           next unless m
 
-          role = m[1].to_sym
+          query = parse_scale_query(m[1])
           host = next_available_host
           if host
-            actions   << { action: :replicate_role, role: role, host: host }
-            rationale << "scale_signal requests :#{role} at #{host}"
+            actions   << { action: :replicate_capabilities, query: query.to_h, host: host }
+            rationale << "scale_signal requests #{query.label.inspect} at #{host}"
           end
         end
       end
@@ -122,12 +124,12 @@ module Igniter
         result   = @llm.call(
           topology:       @topology.nodes.map { |n|
                             { node_id: n.node_id, host: n.host,
-                              role: n.role, healthy: n.healthy }
+                              capabilities: n.capabilities, tags: n.tags, healthy: n.healthy }
                           },
           episodes:       episodes.map { |e|
                             { type: e.type, content: e.content, outcome: e.outcome }
                           },
-          required_roles: @required_roles,
+          required_capabilities: @required_capabilities.map(&:to_h),
           host_pool:      @host_pool
         )
         ExpansionPlan.new(actions: Array(result[:actions]), rationale: result[:rationale])
@@ -137,6 +139,16 @@ module Igniter
         used = @topology.nodes.map(&:host).to_set
         @host_pool.find { |h| !used.include?(h) }
       end
+
+      def parse_scale_query(signature)
+        body, tag_part = signature.split("@", 2)
+
+        CapabilityQuery.new(
+          all_of: body.to_s.split("+").reject(&:empty?),
+          tags:   tag_part.to_s.split("+").reject(&:empty?)
+        )
+      end
+    end
     end
   end
 end

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/manifest.rb

@@ -3,7 +3,8 @@
 require "securerandom"
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # Self-description of a running Igniter instance, used during replication.
     #
     # Call Manifest.current to capture the current process's metadata.
@@ -41,5 +42,6 @@ module Igniter
         }
       end
     end
+    end
   end
 end

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/network_topology.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # Thread-safe in-memory registry of known nodes in the deployment network.
     #
     # Updated by ReflectiveReplicationAgent as nodes are spawned, heartbeat-ed,
@@ -9,14 +10,22 @@ module Igniter
     #
     # @example
     #   topology = NetworkTopology.new
-    #   topology.register(node_id: "abc", host: "10.0.0.2", role: :worker)
-    #   topology.nodes(role: :worker)      # => [NodeEntry]
-    #   topology.needs_role?(:coordinator) # => true
+    #   topology.register(node_id: "abc", host: "10.0.0.2", capabilities: %i[local_llm container_runtime])
+    #   topology.nodes(capability: :local_llm) # => [NodeEntry]
+    #   topology.needs_capability_query?([:local_llm, :container_runtime]) # => false
     class NetworkTopology
       # Mutable record for a single live node (mutated only inside the Mutex).
-      NodeEntry = Struct.new(:node_id, :host, :role,
+      NodeEntry = Struct.new(:node_id, :host, :profile,
                              :registered_at, :last_seen_at, :healthy,
-                             keyword_init: true)
+                             keyword_init: true) do
+        def capabilities
+          profile&.capabilities || []
+        end
+
+        def tags
+          profile&.tags || []
+        end
+      end
 
       def initialize
         @nodes = {}
@@ -27,14 +36,17 @@ module Igniter
       #
       # @param node_id [String]
       # @param host    [String]
-      # @param role    [Symbol, nil]
+      # @param profile       [NodeProfile, nil]
+      # @param capabilities  [Array<Symbol>]
+      # @param tags          [Array<Symbol>]
       # @return [NodeEntry]
-      def register(node_id:, host:, role: nil)
+      def register(node_id:, host:, profile: nil, capabilities: [], tags: [])
         now   = Time.now
+        profile ||= NodeProfile.new(capabilities: capabilities, tags: tags)
         entry = NodeEntry.new(
           node_id:       node_id,
           host:          host,
-          role:          role&.to_sym,
+          profile:       profile,
           registered_at: now,
           last_seen_at:  now,
           healthy:       true
@@ -79,23 +91,37 @@ module Igniter
         @mutex.synchronize { @nodes.delete(node_id) }
       end
 
-      # Return nodes, optionally filtered by role.
+      # Return nodes, optionally filtered by capability or query.
       #
-      # @param role [Symbol, nil]
+      # @param capability [Symbol, String, nil]
+      # @param query [CapabilityQuery, Array<Symbol>, Hash, Symbol, String, nil]
       # @return [Array<NodeEntry>]
-      def nodes(role: nil)
+      def nodes(capability: nil, query: nil)
         @mutex.synchronize do
           entries = @nodes.values.dup
-          role ? entries.select { |e| e.role == role.to_sym } : entries
+          entries = entries.select { |e| e.capabilities.include?(capability.to_sym) } if capability
+          if query
+            normalized = CapabilityQuery.normalize(query)
+            entries = entries.select { |e| normalized.matches_profile?(e.profile) }
+          end
+          entries
         end
       end
 
-      # True when no healthy node with the given role exists.
+      # True when no healthy node with the given capability exists.
       #
-      # @param role [Symbol, String]
+      # @param capability [Symbol, String]
       # @return [Boolean]
-      def needs_role?(role)
-        nodes(role: role).none?(&:healthy)
+      def needs_capability?(capability)
+        nodes(capability: capability).none?(&:healthy)
+      end
+
+      # True when no healthy node satisfies the capability query.
+      #
+      # @param query [CapabilityQuery, Array<Symbol>, Hash, Symbol, String]
+      # @return [Boolean]
+      def needs_capability_query?(query)
+        nodes(query: query).none?(&:healthy)
       end
 
       # Count of healthy nodes across all roles.
@@ -119,5 +145,6 @@ module Igniter
         @mutex.synchronize { @nodes.keys.dup }
       end
     end
+    end
   end
 end

data/packages/igniter-cluster/lib/igniter/cluster/replication/node_profile.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    module Replication
+      # Immutable snapshot of a node's observable runtime traits.
+      #
+      # Profiles bridge host discovery and cluster replication: a node can inspect
+      # its environment, derive capability coordinates, and advertise which
+      # capability queries it can currently satisfy.
+      class NodeProfile
+        DEFAULT_CAPABILITY_MAP = {
+          "ruby" => :ruby,
+          "bundle" => :ruby,
+          "rake" => :ruby,
+          "rspec" => :ruby,
+          "git" => :source_control,
+          "curl" => :http_client,
+          "wget" => :http_client,
+          "jq" => :json_cli,
+          "sqlite3" => :data_store,
+          "psql" => :data_store,
+          "redis-cli" => :data_store,
+          "python3" => :python,
+          "pip3" => :python,
+          "node" => :javascript,
+          "npm" => :javascript,
+          "yarn" => :javascript,
+          "pnpm" => :javascript,
+          "docker" => :container_runtime,
+          "docker-compose" => :container_runtime,
+          "ffmpeg" => :media_processing,
+          "ollama" => :local_llm,
+          "pio" => :embedded,
+          "arduino-cli" => :embedded,
+          "esptool.py" => :embedded,
+          "make" => :native_build,
+          "gcc" => :native_build,
+          "clang" => :native_build
+        }.freeze
+
+        attr_reader :hostname, :platform, :os, :cpu, :utilities,
+                    :capabilities, :tags, :metadata
+
+        def self.from_discovery(snapshot, capabilities: [], tags: [],
+                                capability_map: DEFAULT_CAPABILITY_MAP)
+          utility_candidates = Array(snapshot.dig(:paths, :utility_candidates))
+          discovered = utility_candidates.filter_map do |entry|
+            next unless entry[:present]
+
+            entry[:name].to_s
+          end
+
+          discovered |= Array(snapshot.dig(:paths, :discovered_executables)).map(&:to_s)
+          derived_capabilities = discovered.flat_map { |name| Array(capability_map[name]) }
+
+          new(
+            hostname:     snapshot.dig(:host, :hostname),
+            platform:     snapshot.dig(:host, :platform),
+            os:           snapshot.dig(:host, :os),
+            cpu:          snapshot.dig(:host, :cpu),
+            utilities:    discovered,
+            capabilities: derived_capabilities + Array(capabilities),
+            tags:         inferred_tags(snapshot) + Array(tags),
+            metadata:     { generated_at: snapshot[:generated_at] }
+          )
+        end
+
+        def self.inferred_tags(snapshot)
+          tags = []
+          os   = snapshot.dig(:host, :os).to_s.downcase
+          cpu  = snapshot.dig(:host, :cpu).to_s
+
+          tags << :darwin if os.include?("darwin")
+          tags << :linux if os.include?("linux")
+          tags << cpu.tr("-", "_").to_sym unless cpu.empty?
+
+          ruby_engine = snapshot.dig(:runtime, :ruby, :engine).to_s
+          tags << ruby_engine.to_sym unless ruby_engine.empty?
+          tags
+        end
+
+        def initialize(hostname: nil, platform: nil, os: nil, cpu: nil,
+                       utilities: [], capabilities: [], tags: [], metadata: {})
+          @hostname     = hostname&.to_s
+          @platform     = platform&.to_s
+          @os           = os&.to_s
+          @cpu          = cpu&.to_s
+          @utilities    = Array(utilities).map(&:to_s).uniq.sort.freeze
+          @capabilities = Array(capabilities).map(&:to_sym).uniq.sort.freeze
+          @tags         = Array(tags).map(&:to_sym).uniq.sort.freeze
+          @metadata     = normalize_metadata(metadata).freeze
+          freeze
+        end
+
+        def capability?(capability)
+          @capabilities.include?(capability.to_sym)
+        end
+
+        def tag?(tag)
+          @tags.include?(tag.to_sym)
+        end
+
+        def to_h
+          {
+            hostname: @hostname,
+            platform: @platform,
+            os: @os,
+            cpu: @cpu,
+            utilities: @utilities,
+            capabilities: @capabilities,
+            tags: @tags,
+            metadata: @metadata
+          }
+        end
+
+        private
+
+        def normalize_metadata(value)
+          case value
+          when Hash
+            value.each_with_object({}) do |(key, nested), memo|
+              memo[key.to_sym] = normalize_metadata(nested)
+            end
+          when Array
+            value.map { |item| normalize_metadata(item) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/reflective_replication_agent.rb

@@ -5,26 +5,28 @@ require_relative "replication_agent"
 require_relative "network_topology"
 require_relative "expansion_plan"
 require_relative "expansion_planner"
-require_relative "role_registry"
+require_relative "capability_query"
+require_relative "node_profile"
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # ReplicationAgent extended with episodic memory, self-reflection, and
     # topology-aware network expansion.
     #
     # == Additional message types
     #
-    #   :assess_network  — run ExpansionPlanner; execute replicate_role/retire_node actions
+    #   :assess_network  — run ExpansionPlanner; execute replicate_capabilities/retire_node actions
     #   :reflect         — run a ReflectionCycle over recent episodes; store summary in state
     #   :register_node   — register a remote node in the local NetworkTopology
     #   :node_heartbeat  — update last_seen_at for a known node
-    #   :signal_scale    — emit a :scale_signal episode (e.g. from load monitors)
+    #   :signal_scale    — emit a :scale_signal episode for a capability query
     #
     # == State keys (in addition to inherited :events)
     #
     #   :topology        — NetworkTopology instance (created lazily on first access)
     #   :host_pool       — Array<String> of candidate hosts
-    #   :required_roles  — Array<Symbol> of roles that must always be present
+    #   :required_capabilities — Array<CapabilityQuery-ish> that must always be present
     #   :last_plan       — Hash from the most recent ExpansionPlan
     #   :last_reflection — String summary from the most recent reflection cycle
     #
@@ -38,21 +40,19 @@ module Igniter
     # Call +auto_assess(every: N)+ to schedule periodic topology assessment.
     #
     # @example
-    #   RoleRegistry.define(:worker, env_overrides: { "POOL" => "4" })
-    #
     #   class MyAgent < ReflectiveReplicationAgent
     #     enable_class_memory
     #     auto_assess every: 60
     #   end
     #
     #   ref = MyAgent.start(initial_state: {
-    #     topology:       NetworkTopology.new,
-    #     required_roles: [:worker],
-    #     host_pool:      ["10.0.0.2", "10.0.0.3"]
+    #     topology:              NetworkTopology.new,
+    #     required_capabilities: [[:local_llm]],
+    #     host_pool:             ["10.0.0.2", "10.0.0.3"]
     #   })
     #   ref.call(:assess_network)
     class ReflectiveReplicationAgent < ReplicationAgent
-      initial_state topology: nil, host_pool: [], required_roles: [],
+      initial_state topology: nil, host_pool: [], required_capabilities: [],
                     last_plan: nil, last_reflection: nil
 
       # ── Class-level memory ─────────────────────────────────────────────────────
@@ -63,7 +63,7 @@ module Igniter
         # @param store [Memory::Store, nil] backing store; defaults to global default
         # @return [void]
         def enable_class_memory(store: nil)
-          require "igniter/memory"
+          require "igniter/core/memory"
           @class_memory_store   = store || Igniter::Memory.default_store
           @class_memory_enabled = true
         end
@@ -153,10 +153,13 @@ module Igniter
 
       on :register_node do |state:, payload:, **|
         topology = state[:topology] || NetworkTopology.new
+        agent    = new
+        profile  = payload[:profile] || agent.send(:build_profile_from_payload, payload)
+
         topology.register(
           node_id: payload.fetch(:node_id),
           host:    payload.fetch(:host),
-          role:    payload[:role]
+          profile: profile
         )
         state.merge(topology: topology)
       end
@@ -167,10 +170,10 @@ module Igniter
       end
 
       on :signal_scale do |state:, payload:, **|
-        role = payload.fetch(:role)
+        query = CapabilityQuery.normalize(payload[:query] || payload[:capabilities] || payload.fetch(:capability))
         class_memory&.record(
           type:    :scale_signal,
-          content: "scale_out:#{role}",
+          content: "scale_out:#{query.compact_signature}",
           outcome: nil
         )
         state
@@ -187,18 +190,18 @@ module Igniter
       def run_assess_network(state, payload)
         topology = state[:topology] || NetworkTopology.new
         planner  = ExpansionPlanner.new(
-          topology:       topology,
-          memory:         self.class.class_memory,
-          required_roles: Array(payload[:required_roles] || state[:required_roles]),
-          host_pool:      Array(payload[:host_pool]      || state[:host_pool])
+          topology:              topology,
+          memory:                self.class.class_memory,
+          required_capabilities: Array(payload[:required_capabilities] || state[:required_capabilities]),
+          host_pool:             Array(payload[:host_pool] || state[:host_pool])
         )
 
         plan = planner.plan
 
         plan.actions.each do |action|
           case action[:action]
-          when :replicate_role
-            run_replicate_role(action, topology)
+          when :replicate_capabilities
+            run_replicate_capabilities(action, topology)
           when :retire_node
             topology.remove(node_id: action[:node_id])
             deliver(:node_retired, node_id: action[:node_id], host: action[:host])
@@ -214,25 +217,43 @@ module Igniter
         state.merge(topology: topology, last_plan: plan.to_h)
       end
 
-      # Execute a :replicate_role action: call run_replicate + register in topology.
+      # Execute a :replicate_capabilities action: call run_replicate + register in topology.
       #
       # @param action   [Hash]
       # @param topology [NetworkTopology]
-      def run_replicate_role(action, topology)
-        role_obj = RoleRegistry.registered?(action[:role]) ? RoleRegistry.fetch(action[:role]) : nil
-        env      = role_obj&.env_overrides || {}
-
+      def run_replicate_capabilities(action, topology)
         run_replicate(
           host:                 action.fetch(:host),
           user:                 action.fetch(:user, "deploy"),
           strategy:             action.fetch(:strategy, :git),
-          env:                  env,
+          env:                  action.fetch(:env, {}),
           bootstrapper_options: action.fetch(:bootstrapper_options, {})
         )
 
-        topology.register(node_id: SecureRandom.uuid, host: action[:host], role: action[:role])
-        deliver(:role_replicated, host: action[:host], role: action[:role])
+        query = CapabilityQuery.normalize(action.fetch(:query))
+        profile = NodeProfile.new(capabilities: query.all_of, tags: query.tags)
+        topology.register(node_id: SecureRandom.uuid, host: action[:host], profile: profile)
+        deliver(:capabilities_replicated, host: action[:host], query: query.to_h)
+      end
+
+      def build_profile_from_payload(payload)
+        return payload[:profile] if payload[:profile].is_a?(NodeProfile)
+
+        discovery = payload[:discovery]
+        if discovery
+          NodeProfile.from_discovery(
+            discovery,
+            capabilities: Array(payload[:capabilities]),
+            tags:         Array(payload[:tags])
+          )
+        else
+          NodeProfile.new(
+            capabilities: Array(payload[:capabilities]),
+            tags:         Array(payload[:tags])
+          )
+        end
       end
     end
+    end
   end
 end

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/replication_agent.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "../agent"
+require "igniter/agent"
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # Agent that handles :replicate messages to deploy Igniter to remote servers.
     #
     # In production, start via ReplicationAgent.start and send messages through
@@ -83,5 +84,6 @@ module Igniter
         deliver(:replication_failed, host: payload[:host], error: e.message)
       end
     end
+    end
   end
 end

data/{lib/igniter → packages/igniter-cluster/lib/igniter/cluster}/replication/ssh_session.rb

@@ -3,7 +3,8 @@
 require "open3"
 
 module Igniter
-  module Replication
+  module Cluster
+    module Replication
     # Thin subprocess wrapper over the +ssh+ and +scp+ CLI tools.
     #
     # Provides exec/exec! for running remote commands and upload! for
@@ -73,5 +74,6 @@ module Igniter
         opts
       end
     end
+    end
   end
 end

data/packages/igniter-cluster/lib/igniter/cluster/replication.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "replication/manifest"
+require_relative "replication/ssh_session"
+require_relative "replication/bootstrapper"
+require_relative "replication/bootstrappers/git"
+require_relative "replication/bootstrappers/gem"
+require_relative "replication/bootstrappers/tarball"
+require_relative "replication/replication_agent"
+require_relative "replication/capability_query"
+require_relative "replication/node_profile"
+require_relative "replication/network_topology"
+require_relative "replication/expansion_plan"
+require_relative "replication/expansion_planner"
+require_relative "replication/reflective_replication_agent"
+
+module Igniter
+  module Cluster
+    # Deployment and self-replication capabilities for clustered nodes.
+    module Replication
+      ReplicationError = Class.new(Igniter::Error) unless const_defined?(:ReplicationError, false)
+
+      BOOTSTRAPPERS = {
+        git: Bootstrappers::Git,
+        gem: Bootstrappers::Gem,
+        tarball: Bootstrappers::Tarball
+      }.freeze unless const_defined?(:BOOTSTRAPPERS, false)
+
+      def self.bootstrapper_for(strategy, **options)
+        klass = BOOTSTRAPPERS.fetch(strategy.to_sym) do
+          raise ArgumentError,
+                "Unknown bootstrapper: #{strategy}. Available: #{BOOTSTRAPPERS.keys.join(", ")}"
+        end
+        klass.new(**options)
+      end
+    end
+  end
+end