igniter 0.5.1 → 0.5.2

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

@@ -1,286 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,113 +0,0 @@
-# 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

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

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

@@ -1,101 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,6 +0,0 @@
-# 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

@@ -1,109 +0,0 @@
-# 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