hecks 5.0.0 → 7.0.0

data/lib/hecks/ports/query/cursor.rb

@@ -0,0 +1,131 @@
+require "base64"
+require "delegate"
+require "json"
+require_relative "../../query_specification/field_path"
+require_relative "../../query_specification/common/comparison"
+require_relative "../../query_specification/common/limit_spec"
+
+module Hecks
+  module Ports
+    module Query
+      # The position a cursor query pages by: the row's order value and its identity, as one opaque
+      # token, and the rule for which rows follow it.
+      #
+      # The sequence is the one `Ordering` and `NullPolicy.sql_order` give: the order field in the
+      # declared direction, nulls where `nulls` puts them, identity breaking ties in the same
+      # direction. `SqlKeyset` compiles the same rule into SQL.
+      module Cursor
+        # A token the query did not hand out.
+        class Invalid < ArgumentError; end
+
+        # The decoded position: the order field's comparable value (nil when null) and the row id.
+        Position = Struct.new(:value, :id)
+
+        # A declared query asking for one row more than its page, to learn whether another follows.
+        class Widened < SimpleDelegator
+          # @param declared [QuerySpecification::Common::Options] the cursor query
+          # @param size [Integer] the page size the query's `limit` resolves to
+          def initialize(declared, size)
+            super(declared)
+            @limit = QuerySpecification::Common::LimitSpec.new(value: size + 1)
+          end
+
+          # @return [QuerySpecification::Common::LimitSpec] the page size plus one
+          attr_reader :limit
+        end
+
+        module_function
+
+        # @param value [Object, nil] the row's comparable order value
+        # @param id [String] the row's identity
+        # @return [String] the URL-safe token naming that position
+        def encode(value, id) = Base64.urlsafe_encode64(JSON.generate([json_safe(value), id.to_s]), padding: false)
+
+        # @param token [String, nil] an `after` argument
+        # @return [Position, nil] the position, or nil when there is no token
+        # @raise [Invalid] if the token is not one `encode` made
+        def decode(token)
+          return nil if token.nil? || token.to_s.empty?
+
+          value, id = JSON.parse(Base64.urlsafe_decode64(token.to_s))
+          raise Invalid, "after #{token.inspect} is not a cursor" unless id.is_a?(String)
+
+          Position.new(value, id)
+        rescue JSON::ParserError, ArgumentError, TypeError
+          raise Invalid, "after #{token.inspect} is not a cursor this query handed out"
+        end
+
+        # Whether a null sorts before the valued rows in this query's order.
+        def nulls_first?(direction, policy)
+          case policy&.mode.to_s
+          when "first" then true
+          when "last" then false
+          else direction.to_s.downcase != "desc"
+          end
+        end
+
+        # @param rows [Array<Runtime::Instance, Hash>] rows already in query order
+        # @param declared [QuerySpecification::Common::Options] a cursor query
+        # @param args [Hash] the ask's arguments; `:after` carries the token
+        # @return [Array] the rows following the token's position, all of them with no token
+        def after(rows, declared, args)
+          position = decode(args[:after])
+          return rows unless position
+
+          rows.select { |row| follows?(row, declared, position) }
+        end
+
+        # @return [Boolean] whether `row` comes after `position` in the query's order
+        def follows?(row, declared, position)
+          order_by = declared.order_by
+          value = order_by && comparable_value(row, order_by.field)
+          return (id_of(row) <=> position.id) == 1 unless order_by
+
+          sequence(value, id_of(row), position, order_by, declared.null_semantics).positive?
+        end
+
+        # @return [Integer] -1, 0 or 1: where the row sits against the position in query order
+        def sequence(value, id, position, order_by, policy)
+          first = nulls_first?(order_by.direction, policy)
+          return (value.nil? == first ? -1 : 1) if value.nil? != position.value.nil?
+
+          result = ties_by_id(value.nil? ? 0 : value <=> position.value, id, position.id)
+          order_by.direction.to_s.downcase == "desc" ? -result : result
+        end
+
+        # A tie in the order value (or two values that do not compare) falls to identity.
+        def ties_by_id(compared, id, held_id) = compared.nil? || compared.zero? ? id <=> held_id : compared
+
+        # The token naming the last of `rows`, with the page's ordering read off `declared`.
+        def token_for(row, declared)
+          order_by = declared.order_by
+          encode(order_by && comparable_value(row, order_by.field), id_of(row))
+        end
+
+        # Splits rows fetched one past the page into the page and the token of the next one.
+        #
+        # @param rows [Array] up to `size + 1` rows in query order
+        # @param declared [QuerySpecification::Common::Options] the cursor query, unwidened
+        # @param size [Integer] the page size
+        # @return [Array(Array, String, nil)] the page rows and `after`, nil on the last page
+        def split(rows, declared, size)
+          page = rows.first(size)
+          [page, rows.size > size && !page.empty? ? token_for(page.last, declared) : nil]
+        end
+
+        def comparable_value(row, field)
+          json_safe(QuerySpecification::Common::Comparison.comparable(QuerySpecification::FieldPath.dig(row, field)))
+        end
+
+        def id_of(row) = (row.is_a?(Hash) ? row[:id] : row.id).to_s
+
+        def json_safe(value)
+          case value
+          when nil, String, Numeric, true, false then value
+          else value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/query/in_memory.rb

@@ -1,4 +1,5 @@
 require_relative "ordering"
+require_relative "cursor"
 require_relative "../../runtime/value"
 require_relative "../../query_specification/field_path"
 require_relative "../../query_specification/common/comparison"
@@ -6,8 +7,8 @@ require_relative "../../query_specification/common/comparison"
 module Hecks
   module Ports
     module Query
-      # Applies wheres, order_by, offset and limit to an Array of records, in the same order
-      # as `SqlQueryBuilder` so every adapter answers the same page.
+      # Applies wheres, order_by, a cursor's position, offset and limit to an Array of records, in
+      # the same order as `SqlQueryBuilder` so every adapter answers the same page.
       module InMemory
         FieldPath = QuerySpecification::FieldPath
         Comparison = QuerySpecification::Common::Comparison
@@ -24,12 +25,17 @@ module Hecks
         # @return [Array<Runtime::Instance, Hash>] the matching records, ordered and paged
         def execute(records, declared, args = {}, registry: nil)
           matched = filter(records, declared, args, registry)
-          matched = order(matched, declared)
-          # Offset before limit, as SQL means `LIMIT n OFFSET m`; the reverse order returns a short
-          # or empty page (`limit 10, offset 10` would drop everything).
-          matched = matched.drop(resolve(declared.offset.value, args).to_i) if declared.offset
-          matched = matched.first(resolve(declared.limit.value, args).to_i) if declared.limit
-          matched
+          page(order(matched, declared), declared, args)
+        end
+
+        # The cursor's position, then the offset, then the limit.
+        #
+        # Offset before limit, as SQL means `LIMIT n OFFSET m`; the reverse order returns a short
+        # or empty page (`limit 10, offset 10` would drop everything).
+        def page(ordered, declared, args)
+          ordered = Cursor.after(ordered, declared, args) if declared.cursor
+          ordered = ordered.drop(resolve(declared.offset.value, args).to_i) if declared.offset
+          declared.limit ? ordered.first(resolve(declared.limit.value, args).to_i) : ordered
         end
 
         def filter(records, declared, args, registry)
@@ -41,8 +47,9 @@ module Hecks
         end
 
         def order(matched, declared)
-          field = declared.order_by&.field
-          Ordering.apply(matched, declared.order_by, declared.null_semantics,
+          order_by = declared.order_by
+          field = order_by&.field
+          Ordering.apply(matched, order_by, declared.null_semantics,
                          identity: ->(record) { record.id.to_s }) { |record| comparable(FieldPath.dig(record, field)) }
         end
 

data/lib/hecks/ports/query.rb

@@ -33,8 +33,9 @@ module Hecks
       def validate!(specification, adapter)
         raise Unsupported, "a query cannot combine cursor and offset pagination" if specification.cursor && specification.offset
 
-        return if specification.inspection.nil? || adapter.respond_to?(:inspect_query)
-        return if specification.inspection.mode.to_s == "sql" && adapter.respond_to?(:query)
+        inspection = specification.inspection
+        return if inspection.nil? || adapter.respond_to?(:inspect_query)
+        return if inspection.mode.to_s == "sql" && adapter.respond_to?(:query)
 
         raise Unsupported, "#{adapter.class} cannot inspect generated queries"
       end
@@ -43,4 +44,5 @@ module Hecks
 end
 
 require_relative "query/ordering"
+require_relative "query/cursor"
 require_relative "query/in_memory"

data/lib/hecks/ports.rb

@@ -17,6 +17,7 @@ require_relative "ports/identity_generation"
 require_relative "ports/key_vault"
 require_relative "ports/authorization"
 require_relative "ports/identity_resolution"
+require_relative "ports/authentication"
 require_relative "ports/access_control"
 require_relative "ports/identity_assignment"
 require_relative "ports/agent"

data/lib/hecks/projection_files/expression_tables.rb

@@ -31,9 +31,9 @@ module Hecks
 
       # @return [Hash{String => Hash}] each comparison's declared algebra, by operator symbol
       def comparison_algebra
-        vocabulary = chapter.aggregates.find { |aggregate| aggregate.name == "Vocabulary" }
-        vocabulary.value_objects.find { |value_object| value_object.hecks_name == "Comparison" }
-                  .members.to_h { |row| [row.to_h.values.first, row.to_h] }
+        vocabulary = declaration.aggregates.find { |aggregate| aggregate.name == "Vocabulary" }
+        comparison = vocabulary.value_objects.find { |value_object| value_object.hecks_name == "Comparison" }
+        comparison.members.to_h { |row| [row.to_h.values.first, row.to_h] }
       end
 
       # @param operator [Hash] one admitted operator

data/lib/hecks/projection_files/sentence_table.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Hecks
+  module ProjectionFiles
+    # The sentence-table projection: the phrases an author may write, as the Rust parser's table.
+    # Extended onto `ProjectionFiles`.
+    module SentenceTable
+      # @param root [String] the checkout
+      # @return [Result] `rust/parser/src/phrases.rs`, from the Sentence bluebook
+      def phrase_table(root)
+        require "hecks"
+        text = Projector.call(:phrase_table, bluebook: Projections::PhraseTable.declaration)
+        Result.new({ File.join(root, "rust/parser/src/phrases.rs") => text }, [])
+      end
+    end
+  end
+end

data/lib/hecks/projection_files.rb

@@ -6,13 +6,14 @@ require "tempfile"
 require_relative "rust_format"
 require_relative "projection_files/texts"
 require_relative "projection_files/expression_tables"
+require_relative "projection_files/sentence_table"
 
 module Hecks
   # What each `project_*` generator of the language writes, held as data: absolute path to text.
   #
   # The tables of the language (the model's holding half, the vocabulary, the parser's keywords, the
   # Rust vocabulary, reserved names, field hints, the expression tables and the DSL reference) are
-  # projected from the Bluebook chapter's own declarations. Building them apart from writing them
+  # projected from the Bluebook bluebook's own declarations. Building them apart from writing them
   # lets a caller compare a projection with the tree before anything is changed: a
   # `hecks project_*` verb writes the answer, and the Hecks domain's Language commands report
   # drift and write only when confirmed.
@@ -38,11 +39,12 @@ module Hecks
     }.freeze
 
     # Names of the projections, in the order a full regeneration runs them.
-    NAMES = %i[model vocabulary rust_vocabulary reserved_names parser_table bootstrap_table
+    NAMES = %i[model vocabulary rust_vocabulary reserved_names parser_table phrase_table bootstrap_table
                field_hints expression_tables reference].freeze
 
     extend Texts
     extend ExpressionTables
+    extend SentenceTable
 
     module_function
 
@@ -100,10 +102,10 @@ module Hecks
     end
 
     # @param root [String] the checkout
-    # @return [Result] the model's holding half, one file for each thing the chapter holds
+    # @return [Result] the model's holding half, one file for each thing the bluebook holds
     def model(root)
       require "hecks"
-      files = Projector.call(:model, bluebook: chapter)
+      files = Projector.call(:model, bluebook: declaration)
       out = File.join(root, "lib/hecks/bluebook")
       Result.new(files.to_h { |relative, text| [File.join(out, relative), text] }, [])
     end
@@ -121,7 +123,7 @@ module Hecks
     def rust_vocabulary(root)
       require "hecks"
       kernel = File.join(root, "rust/src/kernel")
-      files = Projector.call(:rust_vocabulary, bluebook: chapter)
+      files = Projector.call(:rust_vocabulary, bluebook: declaration)
       content = files.to_h { |relative, text| [File.join(kernel, relative), text] }
       Result.new(content, Dir.glob(File.join(kernel, "vocab", "*.rs")) - content.keys)
     end
@@ -165,13 +167,14 @@ module Hecks
     end
 
     # @param root [String] the checkout
-    # @return [Result] `rust/host/src/field_hints.rs`, the hints the host's form fields guess from
+    # @return [Result] `rust/host/core/src/field_hints.rs`, the hints the host's form fields guess
+    #   from
     def field_hints(root)
       require "hecks"
-      vocabulary = chapter.aggregates.find { |aggregate| aggregate.hecks_name == "Vocabulary" }
+      vocabulary = declaration.aggregates.find { |aggregate| aggregate.hecks_name == "Vocabulary" }
       field_hint = vocabulary.value_objects.find { |value_object| value_object.hecks_name == "FieldHint" }
       hints = field_hint.members.map(&:to_h)
-      Result.new({ File.join(root, "rust/host/src/field_hints.rs") => field_hints_text(hints) }, [])
+      Result.new({ File.join(root, "rust/host/core/src/field_hints.rs") => field_hints_text(hints) }, [])
     end
 
     # The DSL reference pages and the README regions generated from the same declarations.
@@ -181,7 +184,7 @@ module Hecks
     def reference(root)
       require "hecks"
       directory = File.join(root, "docs/implemented/reference")
-      pages = Projector.call(:reference, bluebook: chapter, options: { from: directory })
+      pages = Projector.call(:reference, bluebook: declaration, options: { from: directory })
       content = pages.to_h { |relative, text| [File.join(directory, relative), text] }
       readme = File.join(root, "README.md")
       content[readme] = Doc::Reference.render_readme(root, File.read(readme))
@@ -189,14 +192,14 @@ module Hecks
     end
 
     # @param projection [Symbol] a projection registered with the projector
-    # @return [String] what it projects from the Bluebook chapter, as the text a file holds
+    # @return [String] what it projects from the Bluebook bluebook, as the text a file holds
     def artifact_text(projection)
-      artifact = Projector.call(projection, bluebook: chapter)
+      artifact = Projector.call(projection, bluebook: declaration)
       artifact.is_a?(String) ? artifact : "#{JSON.pretty_generate(artifact)}\n"
     end
 
-    # @return [Bluebook::Aggregate] the Bluebook chapter, which every projection reads
-    def chapter
+    # @return [Bluebook::Aggregate] the Bluebook bluebook, which every projection reads
+    def declaration
       Bluebook::MetaValidator.grammar_registry.bluebook("Bluebook")
     end
   end

data/lib/hecks/projections/bootstrap_table.rb

@@ -2,12 +2,12 @@ require_relative "../projector"
 
 module Hecks
   module Projections
-    # Projects lib/hecks/bluebook/dsl/bootstrap_table.rb from the chapter's Keyword rows.
+    # Projects lib/hecks/bluebook/dsl/bootstrap_table.rb from the bluebook's Keyword rows.
     # Committed, not built at boot: it is read before the grammar table exists.
     #
-    #   Projector.call(:bootstrap_table, bluebook: <the Bluebook chapter>)
+    #   Projector.call(:bootstrap_table, bluebook: <the Bluebook bluebook>)
     #
-    # Every live row is included, not only those a bootstrap chapter calls.
+    # Every live row is included, not only those a bootstrap bluebook calls.
     module BootstrapTable
       extend Projector::Target
 

data/lib/hecks/projections/ci_pipeline/table/checks.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "tree"
+
+module Hecks
+  module Projections
+    module CiPipeline
+      class Table
+        # What no single row can show: a workflow nothing starts, secrets no caller can pass, a
+        # shard count that is not one a matrix can have, jobs that wait on one another in a circle,
+        # and a command that names a shard total its job does not have.
+        class Checks
+          # The text a step's command writes where its job's shard total belongs.
+          SHARD_TOKEN = "%{shard_total}"
+
+          # One scope of a job's `permissions:` line: a scope, a colon and what is allowed.
+          PERMISSION = /\A[a-z-]+: (read|write|none)\z/
+
+          # A command that begins with whitespace, which a literal block cannot carry.
+          LEADING_SPACE = /\A\s/
+
+          # @param workflows [Array<Tree::Workflow>] the joined workflows
+          # @param vocabulary [Hash{Symbol => Object}] the closed sets and patterns
+          # @param problems [Array<String>] collects each problem found, one line each
+          def initialize(workflows, vocabulary, problems)
+            @workflows = workflows
+            @vocabulary = vocabulary
+            @problems = problems
+          end
+
+          # @return [void]
+          def call
+            @workflows.each do |workflow|
+              check_workflow(workflow)
+              workflow.jobs.each { |job| check_job(job) }
+              check_cycles(workflow)
+            end
+          end
+
+          private
+
+          def check_workflow(workflow)
+            events = @vocabulary.fetch(:trigger)
+            problem(workflow, "has no Trigger row; an event is one of #{events.join(", ")}") if workflow.triggers.empty?
+            if workflow.secrets.any? && !workflow.triggers.include?("workflow_call")
+              problem(workflow, "has Secret rows but no workflow_call Trigger; only a called workflow takes secrets")
+            end
+            return unless workflow.cancel_in_progress && workflow.concurrency_group.empty?
+
+            problem(workflow, "cancels in progress without a concurrency_group to cancel within")
+          end
+
+          def check_job(job)
+            check_time_limit(job)
+            check_shard_total(job)
+            check_shard_axis(job)
+            check_shard_token(job)
+            check_permissions(job)
+            job.steps.select { |step| step.run.match?(LEADING_SPACE) }.each do |step|
+              problem(step, "starts its command with whitespace, which a block scalar cannot carry")
+            end
+          end
+
+          def check_time_limit(job)
+            return if job.timeout_minutes.to_i.positive?
+
+            problem(job, "has timeout_minutes #{job.timeout_minutes.inspect}; a job has a positive time limit")
+          end
+
+          def check_shard_total(job)
+            return unless job.shard_total < 1
+
+            problem(job, "has shard_total #{job.shard_total}; a sharded job has at least one shard")
+          end
+
+          def check_shard_axis(job)
+            if job.shard_total > 1 && job.shard_axis.empty?
+              problem(job, "has shard_total #{job.shard_total} and no shard_axis; the matrix needs a name")
+            elsif job.shard_total <= 1 && !job.shard_axis.empty?
+              problem(job, "has shard_axis #{job.shard_axis.inspect} but shard_total #{job.shard_total}; " \
+                           "a job with one shard has no matrix")
+            end
+          end
+
+          def check_shard_token(job)
+            return if job.shard_total > 1
+
+            job.steps.select { |step| step.run.include?(SHARD_TOKEN) }.each do |step|
+              problem(step, "writes #{SHARD_TOKEN} but its job has no shards")
+            end
+          end
+
+          def check_permissions(job)
+            scopes = job.permissions.split(", ")
+            scopes.grep_v(PERMISSION).each do |scope|
+              problem(job, "has permissions scope #{scope.inspect}; a scope is `<name>: read`, `write` or `none`, " \
+                           "separated by a comma and a space")
+            end
+          end
+
+          # Each cycle among a workflow's jobs, named once from the first job in it.
+          def check_cycles(workflow)
+            needs = needs_among(workflow)
+            reported = []
+            needs.each_key do |name|
+              cycle = cycle_from(name, needs) or next
+              next if reported.include?(cycle.sort)
+
+              reported << cycle.sort
+              problem(workflow, "has jobs that need each other in a circle: #{[*cycle, cycle.first].join(" -> ")}")
+            end
+          end
+
+          # @return [Hash{String => Array<String>}] each job's name to the declared jobs it needs
+          def needs_among(workflow)
+            names = workflow.jobs.map(&:name)
+            workflow.jobs.to_h { |job| [job.name, job.needs & names] }
+          end
+
+          # @return [Array<String>, nil] the jobs of a cycle that begins and ends at `start`
+          def cycle_from(start, needs, path = [start])
+            needs.fetch(path.last).each do |next_job|
+              return path if next_job == start
+              next if path.include?(next_job)
+
+              found = cycle_from(start, needs, [*path, next_job])
+              return found if found
+            end
+            nil
+          end
+
+          def problem(row, text) = @problems << "#{row.label} #{text}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/ci_pipeline/table/lookup.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module CiPipeline
+      class Table
+        # How a row finds what it belongs to: the workflow, job and step its fields name, and the
+        # refusal, naming what is declared, when there is none. Mixed into `Rows`, which holds the
+        # joined workflows in `@workflows` and the problems in `@problems`.
+        module Lookup
+          private
+
+          def workflow_of(row)
+            found = @workflows.find { |workflow| workflow.name == row[:workflow] }
+            return found if found
+
+            problem(row, "names workflow #{row[:workflow].inspect}, which no Workflow row declares; " \
+                         "its workflows are #{@workflows.map(&:name).join(", ")}")
+            nil
+          end
+
+          def job_of(row)
+            workflow = workflow_of(row) or return
+            found = workflow.jobs.find { |job| job.name == row[:job] }
+            return found if found
+
+            problem(row, "names job #{row[:job].inspect}, which workflow #{row[:workflow]} does not declare; " \
+                         "its jobs are #{workflow.jobs.map(&:name).join(", ")}")
+            nil
+          end
+
+          def step_of(job, row)
+            found = job.steps.find { |candidate| candidate.name == row[:step] }
+            return found if found
+
+            problem(row, "names step #{row[:step].inspect}, which job #{row[:job]} does not declare; " \
+                         "its steps are #{job.steps.map(&:name).join(", ")}")
+            nil
+          end
+
+          def check_pattern(row, pattern, field, reason)
+            regexp = @vocabulary.fetch(:patterns).fetch(pattern)
+            return if row[field].is_a?(String) && regexp.match?(row[field])
+
+            problem(row, "has #{field} #{row[field].inspect}; #{reason}, matching #{regexp.source}")
+          end
+
+          def twice(row, declared)
+            return unless declared
+
+            problem(row, "is declared twice")
+          end
+
+          def problem(row, text) = @problems << "#{row.fetch(:label)} #{text}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/ci_pipeline/table/refusals.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module CiPipeline
+      class Table
+        # The refusals a row earns from the bluebook's closed sets and from what its job declares,
+        # each naming the row and listing what is valid. Mixed into `Rows`, which holds the
+        # vocabulary in `@vocabulary` and the problems in `@problems`.
+        module Refusals
+          private
+
+          def refuse_event(row)
+            events = @vocabulary.fetch(:trigger)
+            return if events.include?(row[:event])
+
+            problem(row, "has event #{row[:event].inspect}; an event is one of #{events.join(", ")}")
+          end
+
+          def refuse_unknown_need(row)
+            names = workflow_of(row).jobs.map(&:name)
+            return if names.include?(row[:needs])
+
+            problem(row, "names job #{row[:needs].inspect}, which workflow #{row[:workflow]} does not declare; " \
+                         "its jobs are #{names.join(", ")}")
+          end
+
+          # A step uses an action or runs a command, and an action is one the bluebook admits.
+          def refuse_uses(row)
+            uses = row[:uses]
+            refuse_both(row) unless uses.empty? || row[:run].empty?
+            refuse_neither(row) if uses.empty? && row[:run].empty?
+            refuse_action(row) unless uses.empty?
+          end
+
+          def refuse_both(row)
+            problem(row, "has both uses and run; a step uses an action or runs a command, not both")
+          end
+
+          def refuse_neither(row)
+            problem(row, "has neither uses nor run; a step uses an action or runs a command")
+          end
+
+          def refuse_action(row)
+            actions = @vocabulary.fetch(:uses)
+            return if actions.include?(row[:uses])
+
+            problem(row, "has uses #{row[:uses].inspect}; uses is one of #{actions.join(", ")}")
+          end
+
+          def refuse_input_of_command(row)
+            problem(row, "names a step that runs a command; only a step that uses an action takes inputs")
+          end
+        end
+      end
+    end
+  end
+end