@@ -17,6 +17,7 @@
 * [#3051](https://github.com/ruby-grape/grape/pull/3051): Look up the validation error format once per response instead of once per message - [@ericproulx](https://github.com/ericproulx).
 * [#3055](https://github.com/ruby-grape/grape/pull/3055): Stop a 405 behind `Rack::Cascade` from making the next app answer 405 too - [@ericproulx](https://github.com/ericproulx).
 * [#3058](https://github.com/ruby-grape/grape/pull/3058): Declare `rexml` in the test bundle instead of relying on Danger to bring it in - [@ericproulx](https://github.com/ericproulx).
+* [#3061](https://github.com/ruby-grape/grape/pull/3061): Make a helper reach the routes declared above it in its scope - [@ericproulx](https://github.com/ericproulx).
 * Your contribution here.
 
 ### 4.1.0 (2026-10-31)
 
@@ -2874,7 +2874,7 @@ class Twitter::API < Grape::API
 end
 ```
 
-The same goes for `use`, `helpers` and the `before`/`after` callbacks.
+The same goes for `use` and the `before`/`after` callbacks. `helpers` are the exception: they reach every route of their scope, wherever they are declared in it.
 
 Notice that you could combine these two approaches (rescuing custom errors takes precedence). For example, it's useful for handling all exceptions except Grape validation errors.
 
 
@@ -3,6 +3,21 @@ Upgrading Grape
 
 ### Upgrading to >= 4.2.0
 
+#### A helper reaches every route of its scope, wherever it is declared
+
+A `helpers` block or module used to reach only the routes declared below it in the same scope. A route declared above it raised `NameError` when it called the helper ([#34](https://github.com/ruby-grape/grape/issues/34)). Since [#3061](https://github.com/ruby-grape/grape/pull/3061) it reaches every route of its scope, as it already did from an enclosing scope and through `mount`.
+
+So a helper method defined twice in one scope now answers with its last definition in every route of that scope, including the routes declared between the two definitions:
+
+```ruby
+helpers { def greeting = 'first' }
+get('/before') { greeting } # was 'first', now 'second'
+helpers { def greeting = 'second' }
+get('/after') { greeting }  # 'second'
+```
+
+To keep a different method per route, give the methods different names, or declare the routes in separate namespaces, each with its own `helpers`. `use`, `rescue_from` and the `before`/`after` callbacks still apply only to the routes declared below them.
+
 #### A request every route declines answers 404, however many routes declined
 
 A route declines a request by answering with `X-Cascade: pass`, as a version declared with `cascade: true` does for a version it does not serve. As the [README](README.md#header) documents, the router then answers its own `404` if no other route takes the request. It only did so when one route had declined: with two or more routes on the path, the last one's response came back instead, and so did that of an ANY route (since 4.0.0). So a request for an unknown version answered `404` from an API with one version and `406` from an API with several.
 
@@ -113,6 +113,10 @@ def initialize(new_settings, http_methods:, path:, api:, app: nil, params: {}, r
         source: self.class.block_to_unbound_method(block)
       )
       @endpoints = app.endpoints if app.respond_to?(:endpoints)
+      # The live settings of the scope the route is declared in. The copy in
+      # the State holds that scope's helpers as they were at this line; these
+      # also hold the ones declared further down, read once the API compiles.
+      @scope_setting = new_settings
     end
 
     # Update our settings from a given parent settings instance. Used when
@@ -353,7 +357,7 @@ def compile!
     # sets, which fits an 80-byte slot until a route block or a helper sets one
     # of its own; carrying the route-building state as well, it took 320. The
     # endpoint itself counts too when there are no helpers, both being a
-    # Grape::Endpoint, and it holds at most five.
+    # Grape::Endpoint, and it holds at most six.
     #
     # Helpers reach an endpoint by module inclusion, and +Object#dup+ does not
     # carry a singleton class over — so including them on the per-request copy
@@ -517,8 +521,10 @@ def error_middleware_options(format, content_types)
       }
     end
 
+    # Every helper of the route's scope, wherever it was declared in it, and
+    # of the scopes around it.
     def build_helpers
-      helpers = inheritable_setting.helpers
+      helpers = @scope_setting.helpers
       return if helpers.empty?
 
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
 
@@ -2418,6 +2418,67 @@ def three
       end
       expect { get '/howdy' }.not_to raise_error
     end
+
+    context 'when declared after a route of the same scope' do
+      it 'is accessible from that route' do
+        subject.get '/howdy' do
+          hello
+        end
+
+        subject.helpers do
+          def hello
+            'Hello, world.'
+          end
+        end
+
+        get '/howdy'
+        expect(last_response.body).to eql 'Hello, world.'
+      end
+
+      it 'is accessible from that route in a namespace' do
+        subject.namespace :foo do
+          get :howdy do
+            hello
+          end
+
+          helpers do
+            def hello
+              'Hello, world.'
+            end
+          end
+        end
+
+        get '/foo/howdy'
+        expect(last_response.body).to eql 'Hello, world.'
+      end
+    end
+
+    it 'answers every route of its scope with the last definition of a helper' do
+      subject.helpers do
+        def greeting
+          'first'
+        end
+      end
+
+      subject.get '/before' do
+        greeting
+      end
+
+      subject.helpers do
+        def greeting
+          'second'
+        end
+      end
+
+      subject.get '/after' do
+        greeting
+      end
+
+      get '/before'
+      expect(last_response.body).to eql 'second'
+      get '/after'
+      expect(last_response.body).to eql 'second'
+    end
   end
 
   describe '.scope' do