rooibos 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0bd248d3b6933a881c6a2dc2e01eff42ecf20ae9b8547237f216de1ba3fcc54
-  data.tar.gz: ef8473cff78d86f01022ae554b9a60bf7fdadbfd8528d499cd59ccc592ce5a2a
+  metadata.gz: de0fd230ae66b1f7bb75d7bc0dbaad374d929efe3102638f0dfd2a7558312bc5
+  data.tar.gz: 03bc89ff9e8880b053e022dfdf8bbab94f107e153e174402d9ce5c83b9644c2f
 SHA512:
-  metadata.gz: e3dbe609e9423b3e7e9335c72da14e3eca798d4083baf6f7c17761eeb7f42267bd68d391e6e0102d225f9c3f7e4fc1799221547440baa2d5f9c28beed96ac5b8
-  data.tar.gz: 49d737453d32dc06193baf1b529270938ae8861afcf9f2e5c1faef0a6a04b594d2cd8d63dfb4892c51b2b64b5e06c52c3dbbb260daaa7184a961d0969ca26b39
+  metadata.gz: de7f4335062b9feefca507ef70b058d1561efe6d3fd69ccf764c2b1e4809d17bd3378380b752cf5c1108957dc7ca94a249b276fe1058c1fe6d9abbecc8d1f060
+  data.tar.gz: b50d6ddb3cc4ab37d0d2514d3852c95dbedd6c4cb756cbcb7fe7fcf8937189e7137961704bc1a284a9777f5ee83bd8fe263f9bad99e71f45ea5e29d1da6c864e

data/LICENSES/BSD-2-Clause.txt

@@ -0,0 +1,9 @@
+Copyright (c) <year> <owner> 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/REUSE.toml

@@ -27,3 +27,8 @@ SPDX-License-Identifier = "LGPL-3.0-or-later"
 path = 'doc/images/*'
 SPDX-FileCopyrightText = "2026 Kerrick Long <me@kerricklong.com>"
 SPDX-License-Identifier = "CC-BY-SA-4.0"
+
+[[annotations]]
+path = 'examples/tutorial/**'
+SPDX-FileCopyrightText = "2026 Kerrick Long <me@kerricklong.com>"
+SPDX-License-Identifier = "MIT-0"

data/lib/rooibos/cli/commands/new.rb

@@ -236,6 +236,13 @@ module Rooibos
             end
           end
 
+          # Overwrite bundle gem's .rubocop.yml with Rooibos config
+          rubocop_file = app_path / ".rubocop.yml"
+          if rubocop_file.exist?
+            File.write(rubocop_file.to_s, rubocop_template)
+            puts "Updated #{rubocop_file}"
+          end
+
           # Make initial git commit if git is enabled and bundle didn't
           if git_enabled?(passthrough_args)
             make_initial_commit(app_path)
@@ -367,6 +374,23 @@ module Rooibos
           RUBY
         end
         private_class_method :test_template
+
+        def self.rubocop_template
+          <<~YAML
+            inherit_gem:
+              rooibos: lib/rooibos/rubocop.yml
+
+            AllCops:
+              TargetRubyVersion: 3.2
+
+            Style/StringLiterals:
+              EnforcedStyle: double_quotes
+
+            Style/StringLiteralsInInterpolation:
+              EnforcedStyle: double_quotes
+          YAML
+        end
+        private_class_method :rubocop_template
       end
     end
   end

data/lib/rooibos/command/batch.rb

@@ -98,6 +98,16 @@ module Rooibos
           out.put(Message::Batch.new(command: self))
         end
       end
+
+      def extract_bubbles # :nodoc:
+        bubbles, rest = commands.partition { |c| c.is_a?(Bubble) }
+        remaining = case rest.size
+          when 0 then nil
+          when 1 then rest.first
+          else Batch.new(*rest)
+        end
+        [bubbles, remaining]
+      end
     end
     end
   end

data/lib/rooibos/command/bubble.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Command
+    # Carries a message outward through the fragment hierarchy.
+    #
+    # Nested fragments produce signals. Outer fragments consume them. Passing
+    # callbacks down the tree couples fragments tightly. Direct references
+    # make reuse difficult.
+    #
+    # This command wraps a message for bubbling. Outer fragments intercept it
+    # and decide how to handle it. With the Router DSL, use <tt>observe</tt>
+    # or <tt>intercept</tt>. Without the Router, check for <tt>Command::Bubble</tt>
+    # manually and extract the message. Unhandled bubbles can be re-returned
+    # to continue propagation outward.
+    #
+    # The runtime does not execute this command. Outer fragments handle it.
+    # Calling <tt>call</tt> raises an error.
+    #
+    # [message] The payload to propagate outward.
+    class Bubble < Data.define(:message)
+      include Custom
+
+      # No-op: unhandled bubbles that escape the Router hierarchy( when no
+      # fragment intercepts the message) are silently dropped.
+      def call(_out, _token) = nil
+    end
+  end
+end

data/lib/rooibos/command/custom.rb

@@ -69,7 +69,8 @@ module Rooibos
       #
       # When the runtime cancels your command (app exit, navigation, explicit cancel),
       # it calls <tt>token.cancel!</tt> and waits this long for your command to stop.
-      # If your command does not exit within this window, it is force-killed.
+      # If your command does not exit within this window, it is orphaned until
+      # process exit. There is no safe way to force-kill a Ruby thread.
       #
       # *This is NOT a lifetime limit.* Your command runs indefinitely until canceled.
       # A WebSocket open for 15 minutes is fine. This timeout only applies to the
@@ -80,7 +81,7 @@ module Rooibos
       # - <tt>0.5</tt> — Quick HTTP abort, no cleanup needed
       # - <tt>2.0</tt> — Default, suitable for most commands
       # - <tt>5.0</tt> — WebSocket close handshake with remote server
-      # - <tt>Float::INFINITY</tt> — Never force-kill (database transactions)
+      # - <tt>Float::INFINITY</tt> — Wait indefinitely for cooperative exit (database transactions)
       #
       # === Example
       #

data/lib/rooibos/command/deliver.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Command
+    # Delivers a message to Update.
+    #
+    # Sometimes you have data ready now. A synchronous calculation. A value from
+    # the model. You want Update to process it as a message — pattern match on it,
+    # use predicates, the whole workflow.
+    #
+    # This command wraps any message and delivers it to Update via the runtime.
+    #
+    # Use it to send structured messages from Update, or to produce messages
+    # from synchronous operations.
+    #
+    # === Example
+    #
+    # Define a message type:
+    #   class CacheLoaded < Data.define(:envelope, :data)
+    #     include Rooibos::Message::Predicates
+    #   end
+    #
+    # Send from Update:
+    #   in { type: :key, code: "f" }
+    #     cache = load_yaml_cache("auth")
+    #     Command.deliver(CacheLoaded.new(envelope: :auth, data: cache))
+    #
+    # Receive in Update:
+    #   in { type: :cache_loaded, envelope: :auth, data: }
+    #     model.with(auth: data)
+    #
+    # Or use predicates:
+    #   elsif message.cache_loaded? and message.auth
+    #     model.with(auth: message.data)
+    #
+    class Deliver < Data.define(:message)
+      include Custom
+
+      # Sends the message to the runtime.
+      def call(out, _token)
+        out.put(message)
+      end
+    end
+  end
+end

data/lib/rooibos/command/http.rb

@@ -139,7 +139,7 @@ module Rooibos
       end
 
       # Net::HTTP is blocking; no cooperative cancellation possible.
-      # Grace period = 0 means runtime can force-kill immediately.
+      # Grace period = 0 means runtime will orphan the blocked thread immediately.
       def rooibos_cancellation_grace_period = 0
 
       def self.parse_dwim_args(args, method_kw, url_kw, envelope_kw, body_kw, method_keywords) # :nodoc:

data/lib/rooibos/command/lifecycle.rb

@@ -33,7 +33,7 @@ module Rooibos
       # Runs a command synchronously, returning its result.
       #
       # Spawns a thread, races the result against cancellation and timeout.
-      # On cancellation, waits the grace period then kills the thread if needed.
+      # On cancellation, waits the grace period then orphans the thread if needed.
       #
       # [command] Callable with <tt>call(out, token)</tt>.
       # [token]   Parent's cancellation token.
@@ -89,6 +89,8 @@ module Rooibos
           command.call(outlet, cancellation)
         rescue => e
           channel.push Message::Error.new(command:, exception: e)
+        ensure
+          outlet.wait # Don't resolve until children from standing complete
         end
 
         entry = Entry.new(future:, origin:)

data/lib/rooibos/command/outlet.rb

@@ -97,19 +97,29 @@ module Rooibos
 
       # Sends a message to the runtime.
       #
-      # Custom commands produce results. Those results feed back into your
-      # update function. This method handles the wiring.
-      #
-      # Call with one argument to send it directly. Call with multiple
-      # arguments and they arrive as an array.
+      # Custom commands produce results. Messages about those results feed back
+      # into your update function. This method handles the wiring.
       #
       # Use it for complex data flows or transports Rooibos doesn't ship with.
       #
-      # === Example
+      # For structured data and to avoid NoMethodError, define a custom
+      # Message class with +envelope+ and domain-specific fields, and mix in
+      # <tt>Rooibos::Message::Predicates</tt>. This follows the same pattern as
+      # built-in Message types and RatatuiRuby events.
+      #
+      # === Structured Messages
+      #
+      #   class UserFetched < Data.define(:envelope, :user)
+      #     include Rooibos::Message::Predicates
+      #   end
+      #
+      #   out.put(UserFetched.new(envelope: :profile, user: alice))
+      #
+      #   # Update can pattern match:
+      #   # in { type: :user_fetched, envelope: :profile, user: }
       #
-      #   out.put(:done)              # Update receives :done
-      #   out.put(current_user)       # Update receives current_user
-      #   out.put(:user, alice)       # Update receives [:user, alice]
+      #   # Update can also use predicates:
+      #   # message.user if message.user_fetched? and message.profile?
       #
       # Debug mode validates Ractor-shareability.
       def put(*args)

data/lib/rooibos/command.rb

@@ -14,6 +14,8 @@ require_relative "command/batch"
 require_relative "command/all"
 require_relative "command/http"
 require_relative "command/open"
+require_relative "command/deliver"
+require_relative "command/bubble"
 
 module Rooibos
   # Commands represent side effects.
@@ -54,12 +56,39 @@ module Rooibos
     class Exit < Data.define
       include Custom
 
+      # Ruby 3.x does not auto-freeze zero-member Data.define instances,
+      # which prevents Ractor shareability. Explicit freeze is idempotent on 4.0+.
+      def initialize # :nodoc:
+        super
+        freeze
+      end
+
       # Stub - Exit is a sentinel handled by runtime before dispatch.
       def call(_out, _token)
         raise "Exit command should never be dispatched"
       end
     end
 
+    # Internal wrapper for multiple commands to be dispatched separately.
+    #
+    # Router DSL uses this to return multiple commands from observe + keymap
+    # without triggering Message::Batch. The runtime unwraps this and dispatches
+    # each command independently.
+    #
+    # Unlike Batch:
+    # - Does NOT send Message::Batch on completion
+    # - Each command runs and sends its own messages
+    # - Invisible to app developers
+    class Separate < Data.define(:commands) # :nodoc:
+      include Custom
+
+      # Stub - Separate is a sentinel unwrapped by runtime before dispatch.
+      def call(_out, _token)
+        raise "Separate command should never be dispatched directly"
+      end
+    end
+    private_constant :Separate
+
     # Creates a quit command.
     #
     # Returns a sentinel the runtime detects to terminate the application.
@@ -78,6 +107,76 @@ module Rooibos
       Exit.new
     end
 
+    # Delivers a message to Update.
+    #
+    # Custom commands produce results. Those results feed back into your update
+    # function. This factory method wraps a message in a command that delivers
+    # it when executed.
+    #
+    # === Example
+    #
+    #   # Define a message type
+    #   class FetchComplete < Data.define(:envelope, :data)
+    #     include Rooibos::Message::Predicates
+    #   end
+    #
+    #   # Send after a synchronous operation
+    #   result = fetch_data_sync()
+    #   [model, Command.deliver(FetchComplete.new(envelope: :items, data: result))]
+    #
+    #   # Receive in Update
+    #   in { type: :fetch_complete, envelope: :items, data: }
+    #     model.with(items: data)
+    def self.deliver(message)
+      Deliver.new(message:)
+    end
+
+    # Bubbles a message outward through the fragment hierarchy.
+    #
+    # Nested fragments produce results. Sometimes those results belong to an outer
+    # fragment. Passing callbacks or references inward couples fragments tightly.
+    # The hierarchy becomes rigid.
+    #
+    # This command wraps a message for outward propagation. Outer fragments
+    # intercept the bubble and decide how to handle it. With the Router DSL,
+    # use <tt>observe</tt> or <tt>intercept</tt>. Without the Router, check
+    # for <tt>Command::Bubble</tt> manually and extract the message.
+    #
+    # Use it for notifications, validation results, or any signal that flows
+    # from nested fragments to outer containers.
+    #
+    # === Example (Router DSL)
+    #
+    #   # Nested fragment signals completion
+    #   class TaskComplete < Data.define(:envelope, :task_id)
+    #     include Rooibos::Message::Predicates
+    #   end
+    #
+    #   # Return from nested Update
+    #   [model, Command.bubble(TaskComplete.new(envelope: :task, task_id: 42))]
+    #
+    #   # Outer Router observes the bubble
+    #   observe TaskComplete do |model, message|
+    #     model.with(completed_tasks: model.completed_tasks + [message.task_id])
+    #   end
+    #
+    # === Example (Manual Bubbling)
+    #
+    #   # Outer Update handles bubbles without Router
+    #   def self.handle_nested_result(cmd, model)
+    #     return [model, nil] unless cmd.is_a?(Command::Bubble)
+    #
+    #     case cmd.message
+    #     when TaskComplete
+    #       [model.with(completed_tasks: model.completed_tasks + [cmd.message.task_id]), nil]
+    #     else
+    #       [model, cmd]  # Re-bubble outward
+    #     end
+    #   end
+    def self.bubble(message)
+      Bubble.new(message:)
+    end
+
     # Creates a fresh cancellation that never fires.
     #
     # Some I/O operations cannot be canceled mid-execution. Ruby's <tt>Net::HTTP</tt>
@@ -118,7 +217,6 @@ module Rooibos
     #   [model, Cancel.new(handle: model.active_fetch)]
     class Cancel < Data.define(:handle)
       include Custom
-      include Message::Predicates
 
       # Stub - Cancel is a sentinel handled by runtime before dispatch.
       def call(_out, _token)
@@ -214,7 +312,12 @@ module Rooibos
       end
 
       private def stream_execution(out, token)
-        Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+        # pgroup: true spawns the child in its own process group.
+        # On Linux, popen3(string) invokes /bin/sh which may fork (not exec),
+        # so killing just the shell PID leaves the child orphaned. Signaling
+        # the process group (-pid) ensures TERM reaches all descendants.
+        pgroup_opts = Gem.win_platform? ? {} : { pgroup: true }
+        Open3.popen3(command, **pgroup_opts) do |stdin, stdout, stderr, wait_thr|
           stdin.close
           pid = wait_thr.pid
 
@@ -225,7 +328,8 @@ module Rooibos
             # Check cancellation before blocking on IO.select
             if token.canceled? && wait_thr.alive?
               begin
-                Process.kill("TERM", pid)
+                # On Unix, signal the process group; on Windows, kill the process directly
+                Process.kill("TERM", Gem.win_platform? ? pid : -pid)
               rescue Errno::ESRCH
                 # Already dead
               end

data/lib/rooibos/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module Rooibos
+  # Configuration represents the Mealy machine (state, input) pair.
+  # Immutable value object; use with_model to derive new configurations.
+  class Configuration < Data.define(:message, :model)
+    ##
+    # Derives a new Configuration with an updated model.
+    # Returns <tt>self</tt> if <tt>new_model</tt> is <tt>nil</tt>.
+    def with_model(new_model)
+      return self unless new_model
+
+      Configuration.new(message:, model: new_model)
+    end
+
+    ##
+    # Destructures into <tt>[message, model]</tt> array.
+    def to_a
+      [message, model]
+    end
+    alias to_ary to_a
+    alias deconstruct to_a
+  end
+end

data/lib/rooibos/message/bubbled.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Message
+    # Message synthesized by Router when a child fragment bubbles.
+    #
+    # When a child fragment returns <tt>Command.bubble(message)</tt>, the Router
+    # wraps the inner message in Bubbled and dispatches it through the
+    # outward flow (observe, then intercept).
+    #
+    # [message] The inner message that was bubbled.
+    Bubbled = Data.define(:message) do
+      include Predicates
+
+      def deconstruct_keys(_keys)
+        { type: :bubbled, message: }
+      end
+
+      def bubbled?
+        true
+      end
+    end
+  end
+end

data/lib/rooibos/message.rb

@@ -68,11 +68,17 @@ module Rooibos
         end
       end
 
-      # Returns <tt>false</tt> for unknown predicate methods.
+      # Returns <tt>true</tt> if predicate matches <tt>:type</tt> or
+      # <tt>:envelope</tt> from <tt>deconstruct_keys</tt>. Returns
+      # <tt>false</tt> for unknown predicate methods.
       def method_missing(name, *args, **kwargs, &block)
-        return false if name.to_s.end_with?("?") && args.empty? && kwargs.empty?
-
-        super
+        if name.to_s.end_with?("?") && args.empty? && kwargs.empty?
+          predicate = name.to_s.chomp("?").to_sym
+          keys = deconstruct_keys(nil)
+          keys[:type] == predicate || keys[:envelope] == predicate
+        else
+          super
+        end
       end
 
       # Fallback pattern matching for classes without explicit deconstruct_keys.
@@ -89,14 +95,25 @@ module Rooibos
       #   msg = MyCustomMessage.new
       #   msg.deconstruct_keys(nil) # => { type: :my_custom_message }
       #   msg.to_sym                # => :message_my_custom_message
-      def deconstruct_keys(_keys)
+      def deconstruct_keys(keys)
         class_name = self.class.name&.split("::")&.last
         type_name = if class_name
           class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
         else
           :custom
         end
-        { type: type_name }
+
+        # Filter out :type before calling super — Data returns {} if any
+        # requested key is unknown, which breaks pattern matching
+        filtered_keys = keys&.reject { |k| k == :type }
+
+        # Preserve parent's fields (e.g., Data.define members) and add :type
+        parent_keys = begin
+          super(filtered_keys)
+        rescue NoMethodError
+          {} #: Hash[Symbol, untyped]
+        end
+        parent_keys.merge(type: type_name)
       end
 
       # Responds to all predicate methods.
@@ -117,3 +134,4 @@ require_relative "message/batch"
 require_relative "message/error"
 require_relative "message/canceled"
 require_relative "message/routed"
+require_relative "message/bubbled"

data/lib/rooibos/router/action.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Router
+    # :stopdoc:
+    # Lambda action - calls handler directly with (message, model).
+    class LambdaAction < Data.define(:name, :handler)
+      def routed? = false
+
+      def apply(message, model, _routes)
+        result = handler.arity.zero? ? handler.call : handler.call(message, model)
+        Transition.from(result, model)
+      end
+    end
+    private_constant :LambdaAction
+
+    # Routed action - wraps message and delegates through route to fragment.
+    class RoutedAction < Data.define(:name, :fragment)
+      def routed? = true
+
+      def apply(message, model, routes)
+        route = routes.find { |r| r.fragment == fragment }
+        raise ArgumentError, "No route found for fragment #{fragment}" unless route
+        routed_message = Message::Routed.new(envelope: name, event: message)
+        route.delegate(routed_message, model)
+      end
+    end
+    private_constant :RoutedAction
+  end
+end

data/lib/rooibos/router/flow/dispatch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Router
+    # :stopdoc:
+    module Flow
+      module Dispatch
+        private def run_all(rules, message, model)
+          transition = Transition.initial(model)
+          rules.each do |rule|
+            config = Configuration.new(message:, model: transition.model)
+            new_transition = rule.apply_if_matches(config, routes) or next
+            transition = separate_commands(transition, new_transition)
+          end
+          transition
+        end
+
+        private def apply_first_matching(rules, config, transition)
+          rules.each do |rule|
+            new_transition = rule.apply_if_matches(config, routes) or next
+            return separate_commands(transition, new_transition)
+          end
+          nil
+        end
+
+        private def separate_commands(transition, new_transition) = transition
+          .with_model(new_transition.model)
+          .with_separate_command(new_transition.command)
+      end
+    end
+    private_constant :Flow
+  end
+end

data/lib/rooibos/router/flow/inward.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#++
+
+module Rooibos
+  module Router
+    # :stopdoc:
+    module Flow
+      # Inward flow: messages traveling toward the leaves.
+      #
+      # Observe → receive → forward → otherwise.
+      class Inward < Data.define(:observes, :receives, :forwards, :otherwises, :routes)
+        include Dispatch
+
+        def initialize(observes:, receives:, forwards:, otherwises:, routes:)
+          super
+          validate_routes!
+        end
+
+        def call(message, model)
+          transition = run_all(observes, message, model)
+          config = Configuration.new(message:, model: transition.model)
+          apply_first_matching(receives, config, transition) ||
+            apply_first_matching(forwards, config, transition) ||
+            apply_first_matching(otherwises, config, transition) ||
+            transition
+        end
+
+        private def validate_routes!
+          forwards.each { |fwd| Array(fwd.targets).each { |t| routes.for(t) } unless fwd.targets == ALL_ROUTES }
+          otherwises.each { |ow| routes.for(ow.target) }
+        end
+      end
+    end
+    private_constant :Flow
+  end
+end