igniter 0.4.5 → 0.5.1

data/packages/igniter-app/lib/igniter/app/orchestration/runtime_overview_builder.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Orchestration
+      class RuntimeOverviewBuilder
+        def self.latest_event_for(record)
+          latest_event = Array(record[:combined_timeline]).last || Array(record[:timeline]).last
+          latest_event&.dup&.freeze
+        end
+
+        def self.result_snapshot(record)
+          latest_event = latest_event_for(record)
+
+          {
+            id: record[:id],
+            node: record[:node],
+            action: record[:action],
+            runtime_status: record[:runtime_status],
+            runtime_state: record[:runtime_state],
+            runtime_state_class: record[:runtime_state_class],
+            inbox_status: record[:inbox_status],
+            session_lifecycle_state: record[:session_lifecycle_state],
+            agent_result_contract: record[:agent_result_contract],
+            interaction_contract: record[:interaction_contract],
+            tool_runtime: record[:tool_runtime],
+            waiting_on: record[:waiting_on],
+            terminal: !!record[:terminal],
+            latest_runtime_transition: record[:latest_runtime_transition],
+            latest_event: latest_event
+          }.compact.freeze
+        end
+
+        def initialize(execution:, inbox_items:)
+          @execution = execution
+          @inbox_items = Array(inbox_items).map(&:dup).freeze
+          freeze
+        end
+
+        def overview
+          base_overview = execution.orchestration_overview
+          inbox_by_id = @inbox_items.each_with_object({}) { |item, memo| memo[item[:id].to_s] = item }
+          combined_events = []
+
+          records = Array(base_overview[:records]).map do |record|
+            inbox_item = inbox_by_id[record[:id].to_s]
+            combined_timeline = merge_timelines(
+              node_name: record[:node],
+              runtime_timeline: record[:timeline],
+              inbox_history: inbox_item&.dig(:action_history)
+            )
+            event_query = RuntimeEventQuery.new(combined_timeline)
+            combined_events.concat(combined_timeline)
+
+            record.merge(
+              inbox_item_id: inbox_item&.dig(:item_id),
+              inbox_status: inbox_item&.dig(:status),
+              inbox_queue: inbox_item&.dig(:queue),
+              inbox_channel: inbox_item&.dig(:channel),
+              inbox_assignee: inbox_item&.dig(:assignee),
+              inbox_action_history: Array(inbox_item&.dig(:action_history)).map(&:dup).freeze,
+              combined_timeline: combined_timeline,
+              event_summary: event_query.summary,
+              latest_event: event_query.summary[:latest_event]
+            ).freeze
+          end.freeze
+
+          {
+            summary: build_summary(base_overview[:summary], records, combined_events),
+            results: build_results(records),
+            records: records,
+            timeline: base_overview[:timeline],
+            combined_timeline: combined_events.sort_by { |event| event[:timestamp].to_s }.freeze,
+            event_query: RuntimeEventQuery.new(combined_events),
+            transition_query: execution.orchestration_transition_query
+          }.freeze
+        end
+
+        def fallback_record_for(item)
+          node_name = item[:node].to_sym
+          session = execution.agent_sessions.find do |entry|
+            entry.node_name == node_name &&
+              entry.graph.to_s == item[:graph].to_s &&
+              entry.execution_id.to_s == item[:execution_id].to_s
+          end
+          state = execution.cache.fetch(node_name)
+          runtime_timeline = serialize_runtime_timeline(node_name)
+          combined_timeline = merge_timelines(
+            node_name: node_name,
+            runtime_timeline: runtime_timeline,
+            inbox_history: item[:action_history]
+          )
+          event_query = RuntimeEventQuery.new(combined_timeline)
+          runtime_state = Runtime::OrchestrationRuntimeState.build(
+            node_entry: { status: state&.status },
+            state: state,
+            session: session,
+            timeline: runtime_timeline
+          )
+
+          {
+            id: item[:id],
+            node: node_name,
+            action: item[:action],
+            interaction: item[:interaction],
+            reason: item[:reason],
+            guidance: item[:guidance],
+            attention_required: !!item[:attention_required],
+            resumable: !!item[:resumable],
+            status: state&.status || item[:status],
+            runtime_status: runtime_state.runtime_status,
+            runtime_state: runtime_state.state,
+            runtime_state_class: runtime_state.state_class,
+            runtime_terminal: runtime_state.terminal?,
+            latest_runtime_transition: runtime_state.latest_transition,
+            runtime_transitions: runtime_state.transitions,
+            waiting_on: session&.waiting_on || item[:waiting_on],
+            reply_mode: session&.reply_mode || item[:reply_mode],
+            finalizer: session&.finalizer || item[:finalizer],
+            session_policy: session&.session_policy || item[:session_policy],
+            tool_loop_policy: session&.tool_loop_policy || item[:tool_loop_policy],
+            routing_mode: session&.routing_mode || item[:routing_mode],
+            agent_result_contract: session&.agent_result_contract&.to_h,
+            interaction_contract: session&.interaction_contract&.to_h || item[:interaction_contract],
+            tool_runtime: session&.tool_runtime,
+            session_lifecycle_state: session&.lifecycle_state,
+            phase: session&.phase || item[:phase],
+            ownership: session&.ownership,
+            owner_url: session&.owner_url,
+            delivery_route: session&.delivery_route,
+            token: session&.token || item[:token],
+            turn: session&.turn || item[:turn],
+            interactive: session ? session.interactive? : false,
+            terminal: runtime_state.terminal?,
+            continuable: session ? session.continuable? : false,
+            routed: session ? session.routed? : false,
+            session: session&.to_h,
+            timeline: runtime_timeline,
+            inbox_item_id: item[:item_id],
+            inbox_status: item[:status],
+            inbox_queue: item[:queue],
+            inbox_channel: item[:channel],
+            inbox_assignee: item[:assignee],
+            inbox_action_history: Array(item[:action_history]).map(&:dup).freeze,
+            combined_timeline: combined_timeline,
+            event_summary: event_query.summary,
+            latest_event: event_query.summary[:latest_event]
+          }.freeze
+        end
+
+        private
+
+        attr_reader :execution
+
+        def build_summary(base_summary, records, combined_events)
+          base_summary.merge(
+            with_inbox_items: records.count { |record| !record[:inbox_item_id].nil? },
+            by_inbox_status: records.each_with_object(Hash.new(0)) do |record, memo|
+              memo[record[:inbox_status]] += 1 if record[:inbox_status]
+            end.freeze,
+            by_combined_event_type: combined_events.each_with_object(Hash.new(0)) do |event, memo|
+              memo[event[:event]] += 1 if event[:event]
+            end.freeze,
+            recent_combined_events: combined_events.sort_by { |event| event[:timestamp].to_s }.last(10).freeze
+          ).freeze
+        end
+
+        def build_results(records)
+          latest_records = records.filter_map do |record|
+            latest_event = self.class.latest_event_for(record)
+            next unless latest_event
+
+            {
+              id: record[:id],
+              node: record[:node],
+              action: record[:action],
+              runtime_status: record[:runtime_status],
+              runtime_state: record[:runtime_state],
+              runtime_state_class: record[:runtime_state_class],
+              inbox_status: record[:inbox_status],
+              session_lifecycle_state: record[:session_lifecycle_state],
+              latest_event: latest_event[:event],
+              latest_event_class: latest_event[:event_class],
+              latest_timestamp: latest_event[:timestamp],
+              latest_source: latest_event[:source],
+              latest_actor: latest_event[:actor],
+              latest_origin: latest_event[:origin],
+              latest_lifecycle_operation: latest_event[:lifecycle_operation],
+              latest_execution_operation: latest_event[:execution_operation],
+              waiting_on: record[:waiting_on]
+            }.compact.freeze
+          end
+
+          {
+            terminal_records: records.count do |record|
+              %i[completed failed].include?(record[:runtime_status]&.to_sym) ||
+                %i[resolved dismissed].include?(record[:inbox_status]&.to_sym)
+            end,
+            completed_runtime_records: records.count { |record| record[:runtime_status]&.to_sym == :completed },
+            failed_runtime_records: records.count { |record| record[:runtime_status]&.to_sym == :failed },
+            latest_records: latest_records.sort_by { |entry| entry[:latest_timestamp].to_s }.last(5).freeze
+          }.freeze
+        end
+
+        def merge_timelines(node_name:, runtime_timeline:, inbox_history:)
+          runtime_entries = Array(runtime_timeline).map do |entry|
+            build_runtime_event(entry, source: :runtime, node_name: node_name)
+          end
+          inbox_entries = Array(inbox_history).map do |entry|
+            build_runtime_event(
+              {
+                event: entry[:event],
+                status: entry[:status],
+                timestamp: entry[:at],
+                actor: entry[:actor],
+                origin: entry[:origin],
+                actor_channel: entry[:actor_channel],
+                note: entry[:note],
+                requested_operation: entry[:requested_operation],
+                lifecycle_operation: entry[:lifecycle_operation],
+                execution_operation: entry[:execution_operation],
+                payload: entry.dup
+              },
+              source: :inbox,
+              node_name: node_name
+            )
+          end
+
+          (runtime_entries + inbox_entries).sort_by { |entry| entry[:timestamp].to_s }.freeze
+        end
+
+        def serialize_runtime_timeline(node_name)
+          execution.events.events.filter_map do |event|
+            next unless event.node_name == node_name.to_sym
+
+            payload = event.payload || {}
+            {
+              event_id: event.event_id,
+              event: event.type,
+              node: event.node_name,
+              status: event.status,
+              timestamp: event.timestamp,
+              token: payload[:token],
+              turn: payload[:turn],
+              phase: payload[:phase],
+              waiting_on: payload[:waiting_on],
+              payload: payload
+            }.compact.freeze
+          end.freeze
+        end
+
+        def build_runtime_event(entry, source:, node_name:)
+          payload = (entry[:payload] || {}).dup
+          event_status = entry[:status]&.to_sym
+
+          {
+            source: source.to_sym,
+            event_class: source.to_sym == :runtime ? :runtime : :operator,
+            event: entry[:event]&.to_sym,
+            node: (entry[:node] || node_name)&.to_sym,
+            status: event_status,
+            timestamp: entry[:timestamp],
+            terminal: orchestration_event_terminal_status?(event_status),
+            token: entry[:token] || payload[:token],
+            turn: entry[:turn] || payload[:turn],
+            phase: entry[:phase] || payload[:phase],
+            waiting_on: entry[:waiting_on] || payload[:waiting_on],
+            actor: entry[:actor] || payload[:actor],
+            origin: entry[:origin] || payload[:origin],
+            actor_channel: entry[:actor_channel] || payload[:actor_channel],
+            requested_operation: (entry[:requested_operation] || payload[:requested_operation])&.to_sym,
+            lifecycle_operation: (entry[:lifecycle_operation] || payload[:lifecycle_operation])&.to_sym,
+            execution_operation: (entry[:execution_operation] || payload[:execution_operation])&.to_sym,
+            note: entry[:note] || payload[:note],
+            event_id: entry[:event_id],
+            payload: payload.freeze
+          }.compact.freeze
+        end
+
+        def orchestration_event_terminal_status?(status)
+          %i[completed failed resolved dismissed].include?(status&.to_sym)
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/orchestration/runtime_query_overview_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Orchestration
+      class RuntimeQueryOverviewBuilder
+        def self.build(query:, filters:, order_by:, direction:, limit:)
+          query.to_h(limit: limit).merge(
+            query: {
+              filters: (filters || {}).dup.freeze,
+              order_by: order_by&.to_sym,
+              direction: direction&.to_sym,
+              limit: limit
+            }.freeze
+          ).freeze
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/orchestration/runtime_result_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Orchestration
+      class RuntimeResultBuilder
+        def self.build(summary:, record:)
+          {
+            orchestration_runtime_summary: summary,
+            orchestration_runtime_record: record,
+            orchestration_runtime_result: RuntimeOverviewBuilder.result_snapshot(record),
+            orchestration_runtime_latest_event: RuntimeOverviewBuilder.latest_event_for(record),
+            orchestration_runtime_latest_transition: record[:latest_runtime_transition]&.dup&.freeze,
+            orchestration_runtime_status: record[:runtime_status],
+            orchestration_runtime_state: record[:runtime_state],
+            orchestration_runtime_state_class: record[:runtime_state_class],
+            orchestration_runtime_timeline: Array(record[:combined_timeline] || record[:timeline]).map(&:dup).freeze
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/orchestration.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "orchestration/plan"
+require_relative "orchestration/followup_request"
+require_relative "orchestration/planner"
+require_relative "orchestration/lane_registry"
+require_relative "orchestration/policy_registry"
+require_relative "orchestration/policies"
+require_relative "orchestration/routing_registry"
+require_relative "orchestration/handler_registry"
+require_relative "orchestration/handlers"
+require_relative "orchestration/inbox"
+require_relative "orchestration/inbox_query"
+require_relative "orchestration/operator_query"
+require_relative "orchestration/runtime_event_query"
+require_relative "orchestration/action_result_builder"
+require_relative "orchestration/runtime_overview_builder"
+require_relative "orchestration/runtime_query_overview_builder"
+require_relative "orchestration/runtime_result_builder"
+require_relative "orchestration/result"
+require_relative "orchestration/runner"
+
+Igniter::App::Orchestration::LaneRegistry.register(
+  :open_interactive_session,
+  lane: :interactive_sessions,
+  queue: "interactive-sessions",
+  channel: "inbox://interactive-sessions",
+  policy: Igniter::App::Orchestration::Policies::InteractiveSessionPolicy.new,
+  handler: Igniter::App::Orchestration::Handlers::InteractiveSessionHandler.new,
+  description: "default interactive-session lane"
+)
+Igniter::App::Orchestration::LaneRegistry.register(
+  :require_manual_completion,
+  lane: :manual_completions,
+  queue: "manual-completions",
+  channel: "inbox://manual-completions",
+  policy: Igniter::App::Orchestration::Policies::ManualCompletionPolicy.new,
+  handler: Igniter::App::Orchestration::Handlers::CompletionHandler.new,
+  description: "default manual-completion lane"
+)
+Igniter::App::Orchestration::LaneRegistry.register(
+  :await_single_turn_completion,
+  lane: :single_turn_completions,
+  queue: "single-turn-completions",
+  channel: "inbox://single-turn-completions",
+  policy: Igniter::App::Orchestration::Policies::SingleTurnCompletionPolicy.new,
+  handler: Igniter::App::Orchestration::Handlers::CompletionHandler.new,
+  description: "default single-turn completion lane"
+)
+Igniter::App::Orchestration::LaneRegistry.register(
+  :await_deferred_reply,
+  lane: :deferred_replies,
+  queue: "deferred-replies",
+  channel: "inbox://deferred-replies",
+  policy: Igniter::App::Orchestration::Policies::DeferredReplyPolicy.new,
+  handler: Igniter::App::Orchestration::Handlers::CompletionHandler.new,
+  description: "default deferred-reply lane"
+)
+
+Igniter::App::Orchestration::PolicyRegistry.register(
+  :open_interactive_session,
+  Igniter::App::Orchestration::Policies::InteractiveSessionPolicy.new
+)
+Igniter::App::Orchestration::PolicyRegistry.register(
+  :require_manual_completion,
+  Igniter::App::Orchestration::Policies::ManualCompletionPolicy.new
+)
+Igniter::App::Orchestration::PolicyRegistry.register(
+  :await_single_turn_completion,
+  Igniter::App::Orchestration::Policies::SingleTurnCompletionPolicy.new
+)
+Igniter::App::Orchestration::PolicyRegistry.register(
+  :await_deferred_reply,
+  Igniter::App::Orchestration::Policies::DeferredReplyPolicy.new
+)
+
+Igniter::App::Orchestration::RoutingRegistry.register(
+  :open_interactive_session,
+  queue: "interactive-sessions",
+  channel: "inbox://interactive-sessions"
+)
+Igniter::App::Orchestration::RoutingRegistry.register(
+  :require_manual_completion,
+  queue: "manual-completions",
+  channel: "inbox://manual-completions"
+)
+Igniter::App::Orchestration::RoutingRegistry.register(
+  :await_single_turn_completion,
+  queue: "single-turn-completions",
+  channel: "inbox://single-turn-completions"
+)
+Igniter::App::Orchestration::RoutingRegistry.register(
+  :await_deferred_reply,
+  queue: "deferred-replies",
+  channel: "inbox://deferred-replies"
+)
+
+Igniter::App::Orchestration::HandlerRegistry.register(
+  :open_interactive_session,
+  Igniter::App::Orchestration::Handlers::InteractiveSessionHandler.new
+)
+Igniter::App::Orchestration::HandlerRegistry.register(
+  :require_manual_completion,
+  Igniter::App::Orchestration::Handlers::CompletionHandler.new
+)
+Igniter::App::Orchestration::HandlerRegistry.register(
+  :await_single_turn_completion,
+  Igniter::App::Orchestration::Handlers::CompletionHandler.new
+)
+Igniter::App::Orchestration::HandlerRegistry.register(
+  :await_deferred_reply,
+  Igniter::App::Orchestration::Handlers::CompletionHandler.new
+)

data/packages/igniter-app/lib/igniter/app/runtime.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "igniter/sdk"
+require_relative "runtime_pack"

data/packages/igniter-app/lib/igniter/app/runtime_context.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module RuntimeContext
+      class << self
+        def current
+          Thread.current[:igniter_app_runtime_context]
+        end
+
+        def current=(value)
+          Thread.current[:igniter_app_runtime_context] = value
+        end
+
+        def capture(app_class:, host_config:, host_name:, loader_name:, scheduler_name:, sdk_capabilities:,
+                    loader_adapter:, scheduled_jobs:, code_paths:)
+          self.current = {
+            app_class: app_class,
+            app_name: app_class.name,
+            root_dir: app_class.root_dir,
+            host: host_name,
+            loader: loader_name,
+            scheduler: scheduler_name,
+            sdk_capabilities: Array(sdk_capabilities).map(&:to_sym).sort,
+            loader_runtime: {
+              adapter_class: loader_adapter&.class&.name,
+              code_paths: deep_dup(code_paths),
+              path_groups: code_paths.keys.map(&:to_sym).sort,
+              total_paths: code_paths.values.sum(&:size)
+            },
+            scheduler_runtime: {
+              adapter_class: nil,
+              scheduled_jobs: Array(scheduled_jobs).map { |job| serialize_job(job) },
+              job_count: Array(scheduled_jobs).size
+            },
+            registrations: host_config.registrations.keys.sort,
+            registration_count: host_config.registrations.size,
+            routes: host_config.custom_routes.size,
+            hooks: {
+              before_request: host_config.before_request_hooks.size,
+              after_request: host_config.after_request_hooks.size,
+              around_request: host_config.around_request_hooks.size
+            },
+            metrics: {
+              configured: !host_config.metrics_collector.nil?,
+              collector_class: host_config.metrics_collector&.class&.name
+            },
+            store: {
+              configured: !host_config.store.nil?,
+              store_class: host_config.store&.class&.name
+            },
+            host_settings: deep_dup(host_config.host_settings),
+            stack: stack_snapshot
+          }.freeze
+        end
+
+        private
+
+        def deep_dup(value)
+          case value
+          when Hash
+            value.each_with_object({}) do |(key, nested), memo|
+              memo[key] = deep_dup(nested)
+            end
+          when Array
+            value.map { |item| deep_dup(item) }
+          else
+            value
+          end
+        end
+
+        def stack_snapshot
+          root_app = ENV["IGNITER_ROOT_APP"]
+          node = ENV["IGNITER_NODE"]
+          environment = ENV["IGNITER_ENV"]
+          return nil if [root_app, node, environment].all? { |value| value.nil? || value.empty? }
+
+          {
+            root_app: presence(root_app),
+            node: presence(node),
+            environment: presence(environment)
+          }.compact
+        end
+
+        def presence(value)
+          return nil if value.nil? || value.empty?
+
+          value
+        end
+
+        def serialize_job(job)
+          {
+            name: job.fetch(:name).to_sym,
+            every: job.fetch(:every),
+            at: job[:at]
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/runtime_pack.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "host_adapter"
+require_relative "host_registry"
+require_relative "host_config"
+require_relative "app_host_pack"
+require_relative "loader_adapter"
+require_relative "loader_registry"
+require_relative "loader_pack"
+require_relative "scheduler_adapter"
+require_relative "scheduler_registry"
+require_relative "scheduler_pack"
+require_relative "app_host_config"
+require_relative "cluster_app_host_config"
+require_relative "app_config"
+require_relative "yml_loader"

data/packages/igniter-app/lib/igniter/app/scaffold_pack.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "generator"
+require_relative "generators/cluster"
+require_relative "generators/dashboard"
+require_relative "generators/playground"

data/packages/igniter-app/lib/igniter/app/scheduler.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    # Lightweight pure-Ruby scheduler for recurring background jobs.
+    # Uses one Thread per job — no external dependencies.
+    #
+    # Usage:
+    #   s = Scheduler.new
+    #   s.add :cleanup, every: "1h" do ... end
+    #   s.add :report,  every: "1d", at: "09:00" do ... end
+    #   s.start
+    #   # later:
+    #   s.stop
+    #
+    # Interval formats accepted by `every:`:
+    #   Integer / Float  — seconds
+    #   "30s"            — 30 seconds
+    #   "5m"             — 5 minutes
+    #   "2h"             — 2 hours
+    #   "1d"             — 1 day
+    #   { hours: 1, minutes: 30 }
+    class Scheduler
+      Job = ::Data.define(:name, :interval, :at_time, :block)
+
+      def initialize(logger: nil)
+        @jobs    = []
+        @threads = []
+        @logger  = logger
+        @mu      = Mutex.new
+        @running = false
+      end
+
+      def add(name, every:, at: nil, &block)
+        @jobs << Job.new(
+          name: name.to_sym,
+          interval: parse_interval(every),
+          at_time: at,
+          block: block
+        )
+      end
+
+      def start
+        @mu.synchronize { @running = true }
+        @jobs.each { |job| @threads << Thread.new { run_job(job) } }
+        self
+      end
+
+      def stop
+        @mu.synchronize { @running = false }
+        @threads.each(&:kill)
+        @threads.clear
+      end
+
+      def job_names
+        @jobs.map(&:name)
+      end
+
+      private
+
+      def run_job(job)
+        sleep initial_delay(job)
+        loop do
+          break unless @mu.synchronize { @running }
+
+          begin
+            job.block.call
+          rescue => e # rubocop:disable Style/RescueStandardError
+            @logger&.error("Scheduler job failed", name: job.name, error: e.message)
+          end
+
+          sleep job.interval
+        end
+      end
+
+      # If `at:` is given (e.g. "09:00"), delay until the next occurrence of that time.
+      def initial_delay(job)
+        return 0 unless job.at_time
+
+        h, m   = job.at_time.split(":").map(&:to_i)
+        now    = Time.now
+        target = Time.new(now.year, now.month, now.day, h, m, 0)
+        target += 86_400 if target <= now
+        target - now
+      end
+
+      def parse_interval(val) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+        case val
+        when Integer, Float then val.to_f
+        when String
+          case val
+          when /\A(\d+)s\z/i then Regexp.last_match(1).to_f
+          when /\A(\d+)m\z/i then Regexp.last_match(1).to_f * 60
+          when /\A(\d+)h\z/i then Regexp.last_match(1).to_f * 3600
+          when /\A(\d+)d\z/i then Regexp.last_match(1).to_f * 86_400
+          else raise ArgumentError, "Unknown interval: #{val.inspect} (use 30s / 5m / 2h / 1d)"
+          end
+        when Hash
+          val.fetch(:seconds, 0) +
+            val.fetch(:minutes, 0) * 60 +
+            val.fetch(:hours, 0) * 3600 +
+            val.fetch(:days, 0) * 86_400
+        else
+          raise ArgumentError, "Interval must be Integer, String, or Hash; got #{val.class}"
+        end
+      end
+    end
+  end
+end