squared 0.6.21 → 0.7.0

data/lib/squared/workspace/project/base.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'logger'
 
 require_relative 'support/class'
+require_relative 'support/utils'
 
 module Squared
   module Workspace
@@ -16,14 +17,15 @@ module Squared
         include Prompt
         include Utils
         include Support
+        include Support::Utils
         include Workspace::Support::Variables
         include Rake::DSL
 
         OPTIONS = Workspace::Support.hashobj
         VAR_SET = %i[parent global script index envname desc dependfile dependname dependindex theme archive env graph
-                     dev prod pass only exclude asdf].freeze
+                     dev prod timeout pass only exclude asdf].freeze
         BLK_SET = %i[run depend doc lint test copy clean].freeze
-        SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?(?:([-.])?(\S+))?\b/.freeze
+        SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?[-.]?(\S+)?\b/.freeze
         URI_SCHEME = %r{\A([a-z][a-z\d+-.]*)://[^@:\[\]\\^<>|\s]}i.freeze
         TASK_METADATA = Rake::TaskManager.record_task_metadata
         private_constant :OPTIONS, :VAR_SET, :BLK_SET, :SEM_VER, :URI_SCHEME, :TASK_METADATA
@@ -99,33 +101,35 @@ module Squared
 
         @@tasks = {}
         @@graph = { _: [] }
-        @@asdf = Pathname.new("#{Dir.home}/.asdf").yield_self do |path|
+        @@asdf = Pathname.new(ENV['ASDF_DIR'] || "#{Dir.home}/.asdf").yield_self do |path|
           version = if path.join('asdf.sh').exist?
                       15
                     elsif ENV['ASDF_DATA_DIR'] && (path = Pathname.new(ENV['ASDF_DATA_DIR'])).exist?
                       16
                     end
-          Struct.new(:path, :version).new(path, version) if version
+          if version
+            config = ENV['ASDF_CONFIG_FILE'] || File.join(Dir.home, '.asdfrc')
+            Struct.new(:path, :version, :config).new(path, version, config)
+          end
         end
         @@print_order = 0
 
         subtasks({
           'graph' => %i[run print].freeze,
           'unpack' => %i[zip gz tar ext],
-          'asdf' => %i[set exec current update latest where reshim]
+          'asdf' => %i[set exec env current update latest where reshim]
         })
 
         attr_reader :name, :workspace, :path, :theme, :group, :parent, :children, :dependfile,
-                    :exception, :pipe, :verbose, :global
+                    :exception, :pipe, :verbose
         attr_accessor :project
 
-        def initialize(workspace, path, name, *, group: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON],
-                       **kwargs)
+        def initialize(workspace, path, name, *, first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
           @path = path
           @workspace = workspace
           @name = name.to_s.freeze
           @project = @path.basename.to_s.freeze
-          @group = group&.to_s.freeze
+          @group = kwargs[:group]&.to_s.freeze
           @envname = env_key(@name).freeze
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
@@ -143,22 +147,28 @@ module Squared
                          else
                            val.nil? ? workspace.verbose : val
                          end
-          self.global = false
+          @global = 0
           @output = []
           @ref = []
           @children = []
-          @events = hashobj.update({ first: first, last: last, error: error })
           @as = hashobj
           @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
+          @on = {
+            event: hashobj.update({ first: first, last: last, error: error }),
+            from: []
+          }
+          @timeout = { _: [{}.compare_by_identity, nil, 0] }
           @log = nil
           @dev = nil
           @prod = nil
           @withargs = nil
           @session = nil
           @index = -1
+          @initargs = kwargs.freeze
           parent_set kwargs[:parent]
           run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
           graph_set kwargs[:graph]
+          timeout_set kwargs[:timeout]
           pass_set kwargs[:pass]
           only_set kwargs[:only]
           exclude_set kwargs[:exclude]
@@ -168,117 +178,6 @@ module Squared
           initialize_ref Base.ref
         end
 
-        def initialize_ref(ref)
-          @ref << ref unless @exclude.include?(ref)
-        end
-
-        def initialize_build(ref, **kwargs)
-          initialize_ref ref
-          if (@script = @workspace.script_get(group: @group, ref: ref))
-            if @script[:log] && !kwargs.key?(:log)
-              kwargs[:log] = @script[:log]
-              @log = nil
-            end
-            @depend = @script[:depend] if @depend.nil?
-            @doc = @script[:doc] if @doc.nil?
-            @lint = @script[:lint] if @lint.nil?
-            @test = @script[:test] if @test.nil?
-            @clean = @script[:clean] if @clean.nil?
-            @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
-          end
-          initialize_events(ref, **kwargs)
-          initialize_logger(**kwargs)
-          return if @output[0] == false
-
-          data = @workspace.script_find(*@ref, @group)
-          if @output[0].nil?
-            if data[:script]
-              unless kwargs[:script] == false
-                script_set(data[:script], args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod], global: true)
-              end
-            elsif data[:run]
-              run_set(data[:run], global: true)
-            end
-            if kwargs[:script]
-              script_set(kwargs[:script], args: kwargs[:args]) unless data[:env][:script]
-            elsif @script
-              if @script[:script]
-                script_set(@script[:script], args: @script.fetch(:args, kwargs[:args])) unless data[:global][:script]
-              elsif @script[:run] && !data[:global][:run]
-                run_set @script[:run]
-              end
-            end
-          elsif data[:run] && data[:env][:run]
-            run_set(data[:run], global: true)
-          end
-        end
-
-        def initialize_events(ref, **)
-          return unless (events = @workspace.events_get(group: @group, ref: ref))
-
-          events.each { |task, data| data.each { |ev, blk| @events[ev][task] ||= [blk] } }
-        end
-
-        def initialize_logger(log: nil, **)
-          return if @log
-
-          log = log.is_a?(Hash) ? log.dup : { file: log }
-          file = if (val = env('LOG_FILE'))
-                   Time.now.strftime(val)
-                 elsif (val = env('LOG_AUTO'))
-                   require 'date'
-                   "#{@name}-%s.log" % [case val
-                                        when 'y', 'year'
-                                          Date.today.year
-                                        when 'm', 'month'
-                                          Date.today.strftime('%Y-%m')
-                                        when 'd', 'day', '1'
-                                          Date.today
-                                        else
-                                          val.include?('%') ? Time.now.strftime(val) : Time.now.strftime('%FT%T%:z')
-                                        end]
-                 elsif (val = log[:file])
-                   if val.is_a?(String)
-                     Time.now.strftime(val)
-                   else
-                     require 'date'
-                     "#{@name}-#{Date.today}.log"
-                   end
-                 end
-                 .yield_self do |dir|
-                   @workspace.home.join(env('LOG_DIR', ''), dir).realdirpath if dir
-                 rescue StandardError => e
-                   print_error e
-                 end
-          log[:progname] ||= @name
-          env('LOG_LEVEL', ignore: false) { |s| log[:level] = s.start_with?(/\d/) ? log_sym(s.to_i) : s }
-          log.delete(:file)
-          @log = [file, log]
-        end
-
-        def initialize_env(dev: nil, prod: nil, **)
-          @dev = env_match('BUILD', dev, suffix: 'DEV', strict: true)
-          @prod = env_match('BUILD', prod, suffix: 'PROD', strict: true)
-          env('BUILD', suffix: 'ENV') { |val| @output[2] = val if (val = parse_json(val)) } unless @output[0] == false
-          unless @output[0] == false || @output[0].is_a?(Array)
-            env('BUILD', suffix: 'OPTS') do |val|
-              n = @output[0] ? 1 : 3
-              @output[n] = merge_opts(@output[n], shell_split(val))
-            end
-            env(ref.to_s.upcase, suffix: 'OPTS') { |val| @output[4] = merge_opts(@output[4], shell_split(val)) }
-          end
-          env('BUILD', suffix: 'VERSION') { |val| self.version = val }
-          env('BUILD', strict: true) do |val|
-            if val == '0'
-              @output = [false]
-            elsif script?
-              script_set val
-            else
-              run_set val
-            end
-          end
-        end
-
         def ==(other)
           equal?(other)
         end
@@ -312,10 +211,10 @@ module Squared
             -1
           elsif f.any? { |val| e.include?(val) } # rubocop:disable Lint/DuplicateBranch
             1
-          elsif @index >= 0 && (i = other.instance_variable_get(:@index)) >= 0
+          elsif @index >= 0 && (i = other.index_get) >= 0
             @index <=> i
           end
-        rescue StandardError => e
+        rescue => e
           log&.debug e
           nil
         end
@@ -326,7 +225,7 @@ module Squared
 
         def exception=(val)
           @exception = case val
-                       when Numeric, TrueClass, FalseClass
+                       when Numeric, true, false
                          val
                        else
                          workspace.exception
@@ -344,7 +243,7 @@ module Squared
 
         def verbose=(val)
           @verbose = case val
-                     when Numeric, TrueClass, FalseClass
+                     when Numeric, true, false
                        val
                      else
                        workspace.verbose
@@ -352,7 +251,17 @@ module Squared
         end
 
         def global=(val)
-          @global = val unless val.nil?
+          return if @global == -1
+
+          @global = if val == 0
+                      0
+                    elsif val.nil?
+                      -1
+                    elsif val < 0
+                      @global ^ val.abs
+                    else
+                      @global | val
+                    end
         end
 
         def ref
@@ -375,7 +284,7 @@ module Squared
 
                     format_desc action, flag, '(-)project*'
                     task flag do |_, args|
-                      args = args.to_a.reject { |val| name == val }
+                      args = args.to_a.reject { |val| val == name }
                       if flag == :run
                         graph args
                       else
@@ -434,10 +343,12 @@ module Squared
                         asdf(flag, args, version: version)
                       end
                     else
-                      format_desc(action, flag, ('command' if flag == :exec))
+                      format_desc(action, flag, case flag when :exec, :env then 'command' end)
                       task flag do |_, args|
                         args = args.to_a
-                        args << readline('Enter command', force: true) if args.empty? && flag == :exec
+                        if args.empty? && (flag == :exec || flag == :env)
+                          args << readline('Enter command', force: flag == :exec)
+                        end
                         asdf flag, args
                       end
                     end
@@ -453,7 +364,7 @@ module Squared
         end
 
         def with(**kwargs, &blk)
-          @withargs = (kwargs unless kwargs.empty?)
+          @withargs = kwargs.empty? ? nil : kwargs
           if block_given?
             instance_eval(&blk)
             @withargs = nil
@@ -474,18 +385,17 @@ module Squared
             kwargs = hashdup(@withargs).update(kwargs) if @withargs
             kwargs[:group] = group if group && !kwargs.key?(:group)
             kwargs[:ref] = ref unless kwargs.key?(:ref)
-            proj = nil
             name = case name
                    when String, Symbol
                      name.to_s
                    else
                      path.basename
                    end
+            target = children
             workspace.add(path, name, parent: self, **kwargs) do
-              proj = self
+              target << self
               instance_eval(&blk) if block_given?
             end
-            children << proj
           end
           self
         end
@@ -502,8 +412,8 @@ module Squared
             out.build if out.respond_to?(:build)
           end
           self
-        rescue StandardError => e
-          print_error(e, subject: obj, hint: name)
+        rescue => e
+          print_error(e, subject: name, hint: obj)
           self
         end
 
@@ -521,10 +431,9 @@ module Squared
             args[0] = instance_eval(&blk) || f
             return unless args.first
           end
-          if args.all?(Array)
-            cmd = []
+          if args.all? { |val| val.is_a?(Array) }
             var = {}
-            args.each do |val|
+            cmd = args.each_with_object([]) do |val, out|
               case val.first
               when Proc
                 instance_exec(*val[1..-1], &val.first)
@@ -542,21 +451,20 @@ module Squared
               end
               d = append_hash(d, target: []).join(' ') if d.is_a?(Hash)
               if a
-                cmd << [replace_bin(a), d, b].compact.join(' ')
+                out << [replace_bin(as_get(a, from, 1)), d, b].compact.join(' ')
               else
                 next unless respond_to?(:compose)
 
-                cmd << a if (a = compose(as_get(b, from), d, script: true, args: e, from: from))
+                out << a if (a = compose(as_get(b, from, 2), d, script: true, args: e, from: from))
               end
               var.update(c) if c.is_a?(Hash)
-            end
-            cmd = cmd.join(' && ')
+            end.join(' && ')
           else
             cmd, opts, var, flags, extra = args
             if cmd
               return run_b(cmd, sync: sync, from: from) if cmd.is_a?(Proc) || cmd.is_a?(Method)
 
-              cmd = replace_bin as_get(cmd, from)
+              cmd = replace_bin as_get(cmd, from, 1)
               opts = compose(opts, script: false) if opts && respond_to?(:compose)
               flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
               cmd = case opts
@@ -574,7 +482,7 @@ module Squared
             else
               return unless (opts || extra) && respond_to?(:compose)
 
-              cmd = compose(as_get(opts, from), flags, script: true, args: extra, from: from)
+              cmd = compose(as_get(opts, from, 2), flags, script: true, args: extra, from: from)
               from = :script if from == :run && script?
             end
           end
@@ -590,16 +498,16 @@ module Squared
           graph_deps.flatten(1).sort.each do |proj|
             next if @@graph[:_].include?(proj)
 
-            if (val = ENV["PREREQS_#{proj.instance_variable_get(:@envname)}"] || ENV["PREREQS_#{proj.ref.upcase}"])
+            if (val = ENV["PREREQS_#{proj.envname_get}"] || ENV["PREREQS_#{proj.ref.upcase}"])
               split_escape(val) do |meth|
-                if proj.respond_to?(meth.to_sym)
+                if proj.has?(meth)
                   begin
                     proj.__send__(meth, sync: sync)
-                  rescue StandardError => e
-                    on_error(e, :prereqs, exception: true)
+                  rescue => e
+                    on_error(e, exception: true)
                   end
                 else
-                  print_error(name, "method: #{meth}", subject: 'prereqs', hint: 'undefined')
+                  print_error('prereqs', "method: #{meth}", subject: name, hint: 'undefined')
                 end
               end
             elsif proj.build?
@@ -649,24 +557,24 @@ module Squared
           when Hash
             begin
               @clean.each { |cmd, opts| build(cmd.to_s, opts, sync: sync) }
-            rescue StandardError => e
-              on_error e, :clean
+            rescue => e
+              on_error(e, fatal: prod?)
             end
           else
             if @clean.is_a?(Enumerable) && !series?(@clean)
               @clean.each do |val|
-                entry = basepath(val = val.to_s)
-                if entry.directory? && val.match?(%r{[\\/]\z})
-                  log&.warn "rm -rf #{entry}"
-                  rm_rf(entry, verbose: !silent?)
+                src = basepath(val = val.to_s)
+                if src.directory? && val.match?(%r{[\\/]\z})
+                  log&.warn "rm -rf #{src}"
+                  rm_rf(src, verbose: !silent?)
                 else
-                  log&.warn "rm #{entry}"
-                  (val.include?('*') ? Dir[entry] : [entry]).each do |file|
+                  log&.warn "rm #{src}"
+                  (val.include?('*') ? Dir[src] : [src]).each do |file|
                     next unless File.file?(file)
 
                     File.delete(file)
-                  rescue StandardError => e
-                    log&.error e
+                  rescue => e
+                    print_error(Logger::ERROR, e, subject: name)
                   end
                 end
               end
@@ -690,22 +598,20 @@ module Squared
           end
           env('GRAPH', suffix: 'PASS') { |val| pass.concat(split_escape(val)) }
           start, neg = start.partition { |name| !name.start_with?('-') }
-          data = graph_collect(self, start, pass: neg.map! { |name| name[1..-1] })
+          data = graph_collect(self, start, pass: neg.map { |name| name[1..-1] })
           unless out
             data[name] << self
             on :first, :graph
           end
           ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass, order: order)
-        rescue StandardError => e
-          on_error(e, :graph, exception: true)
+        rescue => e
+          on_error(e, exception: true, dryrun: !out.nil?)
         else
           if out
             if order
-              out.map! do |val|
-                name = ret.find { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }&.name
-                next val unless (n = name && order[name])
-
-                val.subhint(n.succ)
+              out.map do |val|
+                name = ret.find { |proj| val.match?(/ #{Regexp.escape(proj.name)}(@\d|\z)/) }&.name
+                (n = name && order[name]) ? val.subhint(n.succ) : val
               end
             else
               [out, ret]
@@ -841,7 +747,7 @@ module Squared
           ensure
             if dir
               remove_entry dir
-            elsif delete && file.exist?
+            elsif delete && file&.exist?
               file.unlink
             end
           end
@@ -866,8 +772,8 @@ module Squared
                      '--home'
                    end
             cmd << name << version
-          when :exec
-            cmd << name unless opts.first.start_with?(/#{name}\b/)
+          when :env, :exec
+            cmd << name if flag == :env || !opts.first.start_with?(/#{name}\b/)
             cmd.merge(opts)
           when :current
             cmd << '--no-header' unless legacy
@@ -876,7 +782,7 @@ module Squared
             cmd << name
             banner = false if flag == :latest || flag == :where
           end
-          success?(run(banner: banner, from: :"asdf:#{flag}"), flag == :set || flag == :reshim)
+          success?(run(banner: banner, from: symjoin('asdf', flag)), flag == :set || flag == :reshim)
         end
 
         def first(key, *args, **kwargs, &blk)
@@ -893,14 +799,18 @@ module Squared
 
         def event(name, key, *args, override: false, **kwargs, &blk)
           args.unshift(blk) if block_given?
-          ev = @events[name.to_sym]
+          ev = @on[:event][name.to_sym]
           (override ? ev[key.to_sym] = [] : ev[key.to_sym] ||= []) << [args, kwargs]
           self
         end
 
         def as(cmd, script, to = nil)
           data = @as[cmd.to_sym]
-          (to ? [[script, to]] : script).each { |key, val| data[key.to_s] = val }
+          if script.is_a?(Enumerable)
+            script.each { |key, val| data[key.to_s] = val }
+          elsif to
+            data[script.to_s] = to
+          end
           self
         end
 
@@ -917,8 +827,8 @@ module Squared
           self
         end
 
-        def run(cmd = @session, var = nil, exception: self.exception, sync: true, banner: true, from: nil, chdir: path,
-                interactive: nil, hint: nil, series: false, send: :system, **)
+        def run(cmd = @session, var = nil, exception: exception?, sync: true, banner: true, from: nil, chdir: path,
+                interactive: nil, hint: nil, series: false, timeout: nil, **)
           unless cmd
             print_error('no command session started', subject: project, hint: from, pass: true)
             return
@@ -936,6 +846,7 @@ module Squared
             msg = "#{msg} #{sub_style(h, theme[:active])}" if h
             exit 1 unless confirm_basic("#{msg}?", cmd, y)
           end
+          timeout = session_timeout cmd if timeout.nil?
           cmd = session_done cmd
           log&.info cmd
           on :first, from
@@ -956,10 +867,13 @@ module Squared
                 end
               end
               args = var.is_a?(Hash) ? [var, cmd] : [cmd]
-              ret = shell(*args, name: send, chdir: chdir, exception: exception)
+              ret = shell_t(*args, chdir: chdir, exception: exception, timeout: timeout || 0)
             end
-          rescue StandardError => e
-            on_error(e, from, exception: true)
+          rescue Timeout::Error => e
+            print_error(Logger::ERROR, cmd, subject: name, hint: e)
+            exit 1 unless exception?(Logger::DEBUG, Logger::INFO)
+          rescue => e
+            on_error(e, exception: true)
             false
           else
             on :last, from
@@ -973,6 +887,51 @@ module Squared
           end
         end
 
+        def global(*args)
+          @global > 0 && @global.anybits?(case args.size
+                                          when 1
+                                            args.first
+                                          when 0
+                                            1 | 2
+                                          else
+                                            args.reduce(0) { |a, b| a | b }
+                                          end)
+        end
+
+        def global_set(name = nil, **kwargs)
+          return if (n = @global) == -1
+
+          @global = 0
+          data = scriptdata(name: name)
+          if n.anybits?(1 << 31)
+            @global = (n & (1 | 2)) | (1 << 31)
+          elsif @output[0] != false
+            kwargs.update(@initargs) if name
+            if @output[0].nil?
+              if data[:script]
+                unless kwargs[:script] == false
+                  script_set(data[:script], args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod], global: true)
+                end
+              elsif data[:run]
+                run_set(data[:run], global: true)
+              end
+              if kwargs[:script]
+                script_set(kwargs[:script], args: kwargs[:args]) unless data[:env][:script]
+              elsif @script
+                if @script[:script]
+                  script_set(@script[:script], args: @script.fetch(:args, kwargs[:args])) unless data[:global][:script]
+                elsif @script[:run] && !data[:global][:run]
+                  run_set @script[:run]
+                end
+              end
+            elsif data[:run] && data[:env][:run]
+              run_set(data[:run], global: true)
+            end
+          end
+          self.global = 4 if data[:global][:doc] && doc?
+          self.global = 8 if data[:global][:test] && test?
+        end
+
         def variable_set(key, *args, **kwargs, &blk)
           if block_given?
             if blocks.include?(key)
@@ -988,6 +947,8 @@ module Squared
               index_set val
             when :graph
               graph_set val
+            when :timeout
+              timeout_set val
             when :pass
               pass_set val
             when :only
@@ -1008,7 +969,7 @@ module Squared
               run_set(output[0], *args, **kwargs)
             when :dependfile
               @dependindex = nil
-              @dependfile = (basepath(*args) if val)
+              @dependfile = val.nil? ? nil : basepath(*args)
             else
               instance_variable_set(:"@#{key}", val)
             end
@@ -1021,25 +982,26 @@ module Squared
         alias apply variable_set
 
         def enabled?(ref = nil, **)
-          return false if ref && !ref?(ref)
+          return false if ref && Array(ref).none? { |val| ref?(val) }
 
           (path.directory? && !path.empty?) || archive?
         end
 
-        def has?(meth, ref = nil)
+        def has?(meth, ref = nil, all: false, missing: false)
           return false if ref && !ref?(ref)
 
-          respond_to?(meth = :"#{meth}?") && __send__(meth)
+          pred = :"#{meth}?"
+          respond_to?(pred, all) ? __send__(pred) : missing
         end
 
         def ref?(val)
           @ref.include?(val)
         end
 
-        def exist?(*args)
-          return false if (args = args.compact).empty?
+        def exist?(*args, type: nil)
+          return false if args.first.nil?
 
-          basepath(*args).exist?
+          type ? !basepath!(*args, type: type).nil? : basepath(*args).exist?
         end
 
         def build?
@@ -1064,10 +1026,9 @@ module Squared
 
         def prereqs?
           target = self
-          loop do
+          begin
             return true if target.graph?
-            break unless (target = target.parent)
-          end
+          end while (target = target.parent)
           false
         end
 
@@ -1104,7 +1065,7 @@ module Squared
         end
 
         def exclude?(*refs)
-          !@exclude.empty? && has_value?(@exclude, refs.flatten)
+          !@exclude.empty? && has_value?(@exclude, *refs)
         end
 
         def task_include?(key, ref = nil)
@@ -1116,7 +1077,7 @@ module Squared
         end
 
         def dependtype(*)
-          dependindex&.succ || 0
+          @dependindex ? @dependindex.succ : 0
         end
 
         def dependname
@@ -1126,7 +1087,7 @@ module Squared
         def log
           return @log unless @log.is_a?(Array)
 
-          @log = Logger.new((@log.first if enabled?), **@log.last)
+          @log = Logger.new(enabled? ? @log.first : nil, **@log.last)
         end
 
         def allref(&blk)
@@ -1168,20 +1129,10 @@ module Squared
           ret = basepath(*args)
           return ret unless ascend && !ret.exist?
 
-          case ascend
-          when String, Pathname
-            root = Pathname.new(ascend).cleanpath
-            root = nil unless root.absolute? && root.directory?
-          end
           path.parent.ascend.each do |dir|
             target = dir.join(*args)
             return target if target.exist?
-
-            if root
-              break if dir == root
-            elsif workspace.root == dir || parent&.path == dir || (ascend.is_a?(String) && dir.join(ascend).exist?)
-              break
-            end
+            break if (ascend.is_a?(String) && dir.join(ascend).exist?) || workspace.root == dir || parent&.path == dir
           end
           ret
         end
@@ -1193,7 +1144,12 @@ module Squared
         def scriptname(from: :run)
           return unless (name = @output[1]) && respond_to?(:compose)
 
-          as_get name, from
+          as_get name, from, 2
+        end
+
+        def scriptdata(*keys, name: nil)
+          ret = @workspace.script_find(*@ref, @group, name: name)
+          keys.empty? ? ret : ret.dig(*keys)
         end
 
         def inspect
@@ -1212,21 +1168,123 @@ module Squared
 
         def script_get(*args, key: nil)
           ret = workspace.script_get(*args, group: group, ref: allref)
-          return ret unless ret && key
+          ret && key ? ret.fetch(key, nil) : ret
+        end
 
-          ret.fetch(key, nil)
+        def index_get
+          @index
+        end
+
+        def envname_get
+          @envname
+        end
+
+        def graph_get
+          @graph
         end
 
         private
 
+        def initialize_ref(ref)
+          @ref << ref unless @exclude.include?(ref)
+        end
+
+        def initialize_build(ref, **kwargs)
+          initialize_ref ref
+          if (@script = @workspace.script_get(group: @group, ref: ref))
+            if @script[:log] && !kwargs.key?(:log)
+              kwargs[:log] = @script[:log]
+              @log = nil
+            end
+            @depend = @script[:depend] if @depend.nil?
+            @doc = @script[:doc] if @doc.nil?
+            @lint = @script[:lint] if @lint.nil?
+            @test = @script[:test] if @test.nil?
+            @clean = @script[:clean] if @clean.nil?
+            @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
+          end
+          @workspace.events_get(group: @group, ref: ref)&.each do |task, data|
+            data.each { |ev, blk| @on[:event][ev][task] ||= [blk] }
+          end
+          initialize_logger kwargs[:log]
+          global_set(script: kwargs[:script], args: kwargs[:args], prod: kwargs[:prod])
+        end
+
+        def initialize_logger(log)
+          return if @log
+
+          log = log.is_a?(Hash) ? log.dup : { file: log }
+          file = if (val = env('LOG_FILE'))
+                   Time.now.strftime(val)
+                 elsif (val = env('LOG_AUTO'))
+                   require 'date'
+                   "#{@name}-%s.log" % [case val
+                                        when 'y', 'year'
+                                          Date.today.year
+                                        when 'm', 'month'
+                                          Date.today.strftime('%Y-%m')
+                                        when 'd', 'day', '1'
+                                          Date.today
+                                        else
+                                          val.include?('%') ? Time.now.strftime(val) : Time.now.strftime('%FT%T%:z')
+                                        end]
+                 elsif (val = log[:file])
+                   if val.is_a?(String)
+                     Time.now.strftime(val)
+                   else
+                     require 'date'
+                     "#{@name}-#{Date.today}.log"
+                   end
+                 end
+                 .yield_self do |path|
+                   next unless path
+
+                   @workspace.home.join(env('LOG_DIR', ''), path).realdirpath
+                 rescue => e
+                   print_error e
+                 end
+          log[:progname] ||= @name
+          env('LOG_LEVEL', ignore: false) { |val| log[:level] = val.start_with?(/\d/) ? log_sym(val.to_i) : val }
+          log.delete(:file)
+          @log = [file, log]
+        end
+
+        def initialize_env(dev: nil, prod: nil, **)
+          @dev = env_match('BUILD', dev, suffix: 'DEV', strict: true)
+          @prod = env_match('BUILD', prod, suffix: 'PROD', strict: true)
+          unless @output[0] == false
+            env('BUILD', suffix: 'ENV') do |val|
+              next unless (val = parse_json(val, kind: nil)).is_a?(Hash)
+
+              @output[2] = val
+            end
+          end
+          unless @output[0] == false || @output[0].is_a?(Array)
+            env('BUILD', suffix: 'OPTS') do |val|
+              n = @output[0] ? 1 : 3
+              @output[n] = merge_opts @output[n], shell_split(val)
+            end
+            env(ref.to_s.upcase, suffix: 'OPTS') { |val| @output[4] = merge_opts @output[4], shell_split(val) }
+          end
+          env('BUILD', suffix: 'VERSION') { |val| self.version = val }
+          env('BUILD', strict: true) do |val|
+            if val == '0'
+              @output = [false]
+            elsif script?
+              script_set(val, global: 1 << 31)
+            else
+              run_set(val, global: 1 << 31)
+            end
+          end
+        end
+
         def puts(*args, **kwargs)
           log_console(*args, pipe: kwargs[:pipe] || pipe)
         end
 
         def run_s(*cmd, sync: true, banner: !silent?, from: nil, **kwargs)
-          cmd.flatten!
           case cmd.last
-          when Hash, TrueClass, FalseClass
+          when Hash, true, false
             var = cmd.pop
           end
           on :first, from
@@ -1235,8 +1293,8 @@ module Squared
               print_run val, banner
               run(val, var, sync: sync, banner: banner, **kwargs)
             end
-          rescue StandardError => e
-            on_error(e, from, exception: kwargs.fetch(:exception, exception))
+          rescue => e
+            on_error(e, exception: kwargs.fetch(:exception, exception?))
           end
           on :last, from
         end
@@ -1250,11 +1308,8 @@ module Squared
           when Proc
             instance_eval(&obj)
           when Method
-            args = if (n = obj.arity.abs) > 0
-                     Array.new(n).tap { |data| data[0] = self }
-                   else
-                     []
-                   end
+            n = obj.arity.abs
+            args = n > 0 ? Array.new(n).tap { |data| data[0] = self } : []
             obj.call(*args)
           else
             if series?(obj)
@@ -1267,8 +1322,25 @@ module Squared
           end
         end
 
-        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], order: nil, depth: 0,
-                         single: false, last: false, context: nil)
+        def run_e(cmd, stderr: false, banner: true, **kwargs)
+          require 'open3'
+          if stderr
+            Open3.popen3(cmd) do |_, out, err|
+              n = write_lines(out, banner: banner, pass: true, **kwargs)
+              if n == 0
+                n = write_lines(err, banner: banner)
+                success?(n == 0, n == 0 && !banner.nil?)
+              else
+                write_lines(err, loglevel: Logger::DEBUG)
+              end
+            end
+          else
+            Open3.popen2e(cmd) { |_, out| write_lines(out, banner: banner, **kwargs) }
+          end
+        end
+
+        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0, single: false,
+                         last: false, order: nil, **kwargs)
           tag = ->(proj) { "#{proj.name}#{"@#{proj.version}" if SEM_VER.match?(proj.version)}" }
           uniq = lambda do |name|
             return [] unless (ret = data[name])
@@ -1304,6 +1376,7 @@ module Squared
                      "#{single ? ' ' : a}#{'   ' * depth.pred}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{f}"
                    end
           end
+          ctx = { sync: sync, pass: pass, done: done, order: order, single: single, depth: depth.succ, context: target }
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
@@ -1316,8 +1389,7 @@ module Squared
                   end
                 end
             unless target.name == name || (none = (t - done).empty?)
-              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, order: order, depth: depth.succ,
-                                                   single: single, last: j == true, context: target)
+              graph_branch(proj, data, tasks, out, last: j == true, **ctx)
             end
             if out
               if none
@@ -1330,20 +1402,20 @@ module Squared
                          final = data.keys.last
                          while k < depth
                            indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
-                           s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
+                           s += "#{indent || (last && data[final].last == kwargs[:context]) ? ' ' : a}   "
                            k += 1
                          end
-                         s + "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
+                         s += "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
                        end
               end
               if order
                 n = order.size
                 order[name] ||= if proj.parent
-                                  if order[key = proj.parent.name]
-                                    order[key] += 1
+                                  if order[s = proj.parent.name]
+                                    order[s] += 1
                                     n.pred
                                   else
-                                    order[key] = n.succ
+                                    order[s] = n.succ
                                     n
                                   end
                                 else
@@ -1356,14 +1428,14 @@ module Squared
                   next if pass.include?(meth)
 
                   if workspace.task_defined?(cmd = task_join(name, meth))
-                    if ENV.key?(key = "BANNER_#{name.upcase}")
+                    if ENV.key?(key = "BANNER_#{envname_get}")
                       key = nil
                     else
                       ENV[key] = '0'
                     end
                     run(cmd, sync: false, banner: false)
                     ENV.delete(key) if key
-                  elsif proj.has?(meth, (workspace.baseref unless tasks || graph))
+                  elsif proj.has?(meth, tasks || graph ? nil : workspace.baseref)
                     proj.__send__(meth.to_sym, sync: sync)
                   end
                 end
@@ -1374,8 +1446,7 @@ module Squared
         end
 
         def graph_collect(target, start = [], data: {}, pass: [], root: [])
-          deps = []
-          (start.empty? ? target.instance_variable_get(:@graph) : start)&.each do |val|
+          deps = Array(start.empty? ? target.graph_get : start).each_with_object([]) do |val, out|
             next if pass.include?(val)
 
             if (obj = workspace.find(name: val))
@@ -1390,8 +1461,8 @@ module Squared
               end
               next if (objs = data.fetch(name, [])).include?(target)
 
-              deps << proj
-              deps.concat(objs)
+              out << proj
+              out.concat(objs)
             end
           end
           deps.uniq!
@@ -1402,39 +1473,31 @@ module Squared
 
         def graph_deps(target = self)
           key = target.name
-          return @@graph[key] if @@graph.key?(key)
-
-          base = []
-          deps = []
-          loop do
-            deps.concat(graph_branch(target, graph_collect(target), []))
-            break unless (target = target.parent)
+          @@graph[key] ||= begin
+            base = []
+            deps = []
+            loop do
+              deps.concat(graph_branch(target, graph_collect(target), []))
+              break unless (target = target.parent)
 
-            base << target
+              base << target
+            end
+            deps.uniq!
+            [base, deps]
           end
-          deps.uniq!
-          @@graph[key] = [base, deps]
         end
 
-        def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
-          name = "#{key}_#{@envname}"
+        def env(key, default = nil, suffix: nil, strict: false, ignore: nil, **kwargs, &blk)
+          name = "#{key}_#{envname_get}"
           ret = if suffix
-                  ENV["#{name}_#{suffix}"] || (ignore == false && ENV["#{key}_#{suffix}"]) || ''
+                  ENV.fetch("#{name}_#{suffix}", '')
                 elsif strict
                   ENV[name].to_s
                 else
                   ignore = ['0'].freeze if ignore.nil?
                   ENV[name] || ENV.fetch(key, '')
                 end
-          if equals.nil?
-            ret = default if ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s })
-            return ret if ret.nil?
-          else
-            ret = Array(equals).any? { |val| ret == val.to_s }
-          end
-          return yield ret if block_given?
-
-          ret
+          env_yield(ret, default, ignore: ignore, **kwargs, &blk)
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
@@ -1442,7 +1505,7 @@ module Squared
           if path && (val = shell_bin(prefix))
             cmd[0] = shell_quote(val, force: false)
           end
-          ret = JoinSet.new(cmd.flatten(1))
+          ret = JoinSet.new(cmd)
           if options
             env("#{prefix.upcase}_OPTIONS") do |val|
               if val.start_with?('-')
@@ -1452,9 +1515,17 @@ module Squared
               end
             end
           end
-          return ret unless main
+          cache = @timeout[:_]
+          cache[1] ||= workspace.timeout_get(*@ref, group: group)
+          cache[0][ret] = if cmd[1..-1].find { |val| val =~ /\A([A-Za-z][\w-]*)(?<![-_])(?: |\z)/ }
+                            command = :"#{prefix}_#{$1}"
+                            cache[1][command] || @timeout[command]
+                          end || cache[1][prefix.to_sym] || @timeout[prefix.to_sym]
+          main ? @session = ret : ret
+        end
 
-          @session = ret
+        def session_timeout(cmd)
+          @timeout[:_][0][cmd] || @timeout[:_][2]
         end
 
         def session_output(*cmd, **kwargs)
@@ -1478,18 +1549,18 @@ module Squared
         end
 
         def session_apply(val, args: nil, kwargs: nil, pass: [], keys: [:opts], exclude: [])
-          a = []
           b = {}
-          Array(val).each do |c|
+          a = Array(val).each_with_object([]) do |c, out|
             d, e, f = session_get c
-            unless (f -= exclude).empty?
+            f -= exclude
+            unless f.empty?
               h = []
               i = {}
-              session_apply(f.map!(&:to_s), args: h, kwargs: i, pass: pass, keys: keys, exclude: exclude.concat(f))
-              a.concat(h)
+              session_apply(f.map(&:to_s), args: h, kwargs: i, pass: pass, keys: keys, exclude: exclude.concat(f))
+              out.concat(h)
               append_keys(b, i, *keys)
             end
-            a.concat(d)
+            out.concat(d)
             append_keys(b, e, *keys)
           end
           if args
@@ -1512,7 +1583,7 @@ module Squared
           return cmd.to_s unless cmd.respond_to?(:done)
 
           raise_error 'no command added', hint: cmd.first unless cmd.size > 1
-          @session = nil if cmd.equal?(@session)
+          @session = nil if cmd == @session
           cmd.done
         end
 
@@ -1522,33 +1593,69 @@ module Squared
           OptionPartition.arg?(target, *args, **kwargs)
         end
 
-        def option(*args, target: @session, prefix: target&.first, **kwargs)
+        def option(*args, target: @session, prefix: target&.first, path: false, escape: false, quote: false, pat: nil,
+                   **kwargs)
           return unless prefix
 
-          args.each do |val|
-            next unless (ret = env(env_key(prefix.to_s.stripext, val), **kwargs))
+          args.each do |key|
+            next unless (ret = env(env_key(prefix.to_s.stripext, key), **kwargs)) && (!pat || ret.match?(pat))
 
+            if path
+              target << quote_option(key, basepath(ret))
+            elsif quote
+              target << quote_option(key, ret)
+            elsif escape
+              target << shell_option(key, ret)
+            end
             return block_given? ? yield(ret) : ret
           end
           nil
         end
 
-        def option_clear(opts, empty = true, target: @session, **kwargs)
-          return unless target
+        def write_lines(data, grep: [], prefix: nil, sub: nil, banner: nil, loglevel: nil, pass: false, first: false)
+          grep = grep.empty? ? nil : matchmap(grep, prefix)
+          sub = stdin? ? nil : as_a(sub)
+          ret = 0
+          lines = data.each_with_object([]) do |line, out|
+            next if grep&.none? { |pat| pat.match?(line) }
+            next if block_given? && !(line = yield(line, ret))
 
-          OptionPartition.clear(target, opts, styles: theme[:inline], **kwargs)
-          opts.clear if empty
-          nil
+            if loglevel
+              log&.add loglevel, line
+            else
+              sub&.each { |h| sub_style!(line, **h) }
+              if banner
+                out << line
+              else
+                puts line
+              end
+            end
+            ret += 1
+            break out if first
+          end
+          print_item banner, lines if banner && (ret > 0 || (!pass && !first))
+          ret
         end
 
         def print_success
-          puts ARG[:SUCCESS]
+          puts 'Success'
         end
 
         def print_error(*args, loglevel: Logger::WARN, **kwargs)
           return unless warning?
 
-          warn log_message(loglevel, *args, **kwargs)
+          loglevel = args.shift if args.first.is_a?(Numeric) && args.first.between?(Logger::DEBUG, Logger::UNKNOWN)
+          if loglevel >= Logger::WARN && exception?(Logger::ERROR, Logger::FATAL)
+            $stderr.puts log_message([loglevel, Logger::Error].max, *args, **kwargs)
+            if exception == Logger::ERROR
+              ex = [args.first, kwargs[:subject], kwargs[:hint]].compact
+              raise(ex.find { |val| val.class < Exception } || ex.first)
+            else
+              exit 1
+            end
+          else
+            warn log_message(loglevel, *args, **kwargs)
+          end
         end
 
         def print_run(cmd, banner = true, verbose: nil, **)
@@ -1561,22 +1668,22 @@ module Squared
         def print_item(*val, series: false)
           puts unless printfirst?
           printsucc unless series
-          puts val unless val.empty? || (val.size == 1 && (!val.first || val.first.empty?))
+          puts val unless val.empty? || (val.size == 1 && !val.first)
         end
 
-        def print_banner(*lines, client: false, styles: theme[:banner], border: borderstyle, **)
+        def print_banner(*lines, client: false, styles: theme[:banner], border: borderstyle)
           pad = 0
           if styles
             if styles.any? { |s| s.to_s.end_with?('!') }
               pad = 1
             elsif !client && styles.size <= 1
-              styles = [:bold] + styles
+              styles += [:bold]
             end
           end
           n = line_width lines
           ch = ' ' * pad
           index = -1
-          lines.map! do |val|
+          ret = lines.map do |val|
             index += 1
             val = ch + val.ljust(n - (pad * 2)) + ch
             if styles && (pad == 1 || index == 0)
@@ -1585,23 +1692,24 @@ module Squared
               val
             end
           end
-          (lines << sub_style(ARG[:BORDER][1] * n, border)).join("\n")
+          ret << sub_style(ARG[:BORDER][1] * n, border)
+          ret.join("\n")
         end
 
-        def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle, **)
+        def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle)
           n = line_width lines
           sub = as_a sub
-          lines.map! do |val|
+          ret = lines.map do |val|
             s = right ? val.rjust(n) : val.ljust(n)
             sub.each { |h| sub_style!(s, **h) }
             s
           end
-          [sub_style(ARG[:BORDER][1] * n, border)].concat(lines)
-                                                  .tap { |ret| ret.reverse! if reverse }
-                                                  .join("\n")
+          ret.unshift(sub_style(ARG[:BORDER][1] * n, border))
+          ret.reverse! if reverse
+          ret.join("\n")
         end
 
-        def print_status(*args, from: nil, **kwargs)
+        def print_status(*args, from: :completed, **kwargs)
           return if stdin? || silent?
 
           case from
@@ -1627,7 +1735,7 @@ module Squared
           workspace.format_desc([@desc, action, flag].compact, opts, **kwargs)
         end
 
-        def format_banner(cmd, banner: true, hint: nil, strip: nil)
+        def format_banner(cmd, banner: true, hint: nil, strip: nil, quote: false)
           return unless banner && banner?
 
           if (data = workspace.banner_get(*@ref, group: group))
@@ -1635,7 +1743,7 @@ module Squared
 
             client = true
           else
-            data = Struct::BannerData.new(true, [:path], theme[:banner], theme[:border])
+            data = Struct::BannerData.new(true, theme[:banner], theme[:border], [:path])
           end
           if verbose
             out = []
@@ -1648,6 +1756,7 @@ module Squared
                 cmd = cmd.gsub(/(?:#{s = Regexp.escape(File.join(path, ''))}?(?=["'])|#{s})/, '')
                          .gsub(/(?: -[^ ])? (?:""|'')/, '')
               end
+              cmd.gsub!(/(?<= )(["'])([\w.-]+)\1(?= |\z)/, '\2') unless quote
               out << cmd.subhint(hint)
             end
             data.order.each do |val|
@@ -1663,7 +1772,7 @@ module Squared
                     __send__ meth
                   end
                 end
-                val = val.reject { |item| !item || item == true }.join(s)
+                val = val.compact.join(s)
                 next unless found && !val.empty?
               elsif (val = __send__(val)).nil?
                 next
@@ -1682,7 +1791,7 @@ module Squared
           unless items.empty?
             pad = items.size.to_s.size
             items.each_with_index do |val, i|
-              next unless matchany?(val.first, reg)
+              next unless matchany?(reg, val.first)
 
               out << ('%*d. %s' % [pad, i.succ, block_given? ? yield(val) : val.first])
             end
@@ -1696,7 +1805,7 @@ module Squared
                     out << ''
                   end
                   if from
-                    out << (from = from.to_s)
+                    out << from
                     /\A(#{Regexp.escape(from)})(.*)\z/
                   end
                 else
@@ -1721,7 +1830,7 @@ module Squared
         end
 
         def append_hash(data, target: @session || [], build: false)
-          if build && (type = env('BUILD', suffix: 'TYPE', ignore: false))
+          if build && (type = env('BUILD', suffix: 'TYPE') || ENV['BUILD_TYPE'])
             if (extra = data[type = "__#{type}__"] || data[type.to_sym]).is_a?(Hash)
               data = data.merge(extra)
             else
@@ -1729,7 +1838,8 @@ module Squared
             end
           end
           data.each do |key, val|
-            next if (key = key.to_s).start_with?('__')
+            key = key.to_s
+            next if key.start_with?('__')
 
             if val.nil? || extra || session_arg?(key, target: target)
               OptionPartition.delete_key(target, key)
@@ -1742,7 +1852,7 @@ module Squared
               append_repeat(key, val, target: target)
             when Numeric
               target << basic_option(key, val)
-            when FalseClass
+            when false
               target << shell_option(key).sub(/^--(?!no-)/, '--no-')
             when Pathname
               target << shell_option(key, val, escape: false)
@@ -1779,9 +1889,7 @@ module Squared
 
         def append_first(*list, target: @session, flag: true, equals: false, escape: true, quote: true, force: true,
                          **kwargs)
-          return if list.empty?
-
-          list.flatten.each do |opt|
+          list.each do |opt|
             next unless (val = option(opt, **kwargs))
 
             return target << if flag
@@ -1795,30 +1903,25 @@ module Squared
 
         def append_option(*list, target: @session, no: false, equals: false, escape: true, quote: true, force: true,
                           **kwargs)
-          return if list.empty?
-
           kwargs[:ignore] = false if no && !kwargs.key?(:ignore)
-          ret = []
-          list.flatten.each do |flag|
+          ret = list.each_with_object([]) do |flag, out|
             next unless (val = option(flag, target: target, **kwargs))
 
             if no && val == '0'
               flag = "no-#{flag}"
               val = nil
             end
-            ret << shell_option(flag, (val if equals), escape: escape, quote: quote, force: force)
+            out << shell_option(flag, (val if equals), escape: escape, quote: quote, force: force)
           end
           merge_list target, ret unless ret.empty?
-          ret
         end
 
-        def append_nocolor(target: @session)
-          target << '--no-color' if !ARG[:COLOR] || stdin? || option('color', target: target, equals: '0')
+        def append_nocolor(flag = '--no-color', target: @session, **kwargs)
+          target << flag if !ARG[:COLOR] || stdin? || option('color', target: target, equals: '0', **kwargs)
         end
 
         def append_keys(base, data, *keys)
-          out = {}
-          keys.each do |key|
+          ret = keys.each_with_object({}) do |key, out|
             next unless data.key?(key)
 
             out[key] = case (val = data[key])
@@ -1831,7 +1934,7 @@ module Squared
                        end
           end
           base.update(data)
-              .update(out)
+              .update(ret)
         end
 
         def merge_opts(base, data)
@@ -1874,22 +1977,9 @@ module Squared
           end
         end
 
-        def merge_list(base, data)
-          data = Array(data)
-          case base
-          when Array
-            base.concat(data)
-          when Set
-            base.merge(data)
-          else
-            Array(base).concat(data)
-          end
-        end
-
         def collect_hash(data, pass: [])
-          ret = []
-          data.each { |key, val| ret.concat(val) unless pass.include?(key) }
-          ret
+          data = data.reject { |key,| pass.include?(key) } unless pass.empty?
+          data.values.flatten
         end
 
         def replace_bin(val)
@@ -1903,14 +1993,13 @@ module Squared
           ret = JSON.parse(val)
           raise_error 'invalid JSON'.subhint(kind.name), val, hint: hint if kind && !ret.is_a?(kind)
           ret
-        rescue StandardError => e
-          log&.warn e
-          print_error(e, subject: name)
+        rescue => e
+          print_error(kind ? Logger::ERROR : Logger::INFO, e, subject: name)
         end
 
         def parse_env(key)
           env(key) do |val|
-            val.start_with?('-') ? shell_parse(val) : split_escape(val).map! { |opt| fill_option(opt) }
+            val.start_with?('-') ? shell_parse(val) : split_escape(val).map { |opt| fill_option(opt) }
           end || []
         end
 
@@ -1928,77 +2017,53 @@ module Squared
           args
         end
 
-        def confirm_basic(msg, hint, default = 'Y', style: :inline, target: @session, prefix: target&.first, **kwargs)
-          return true if option('y', prefix: prefix)
-
-          confirm("#{msg} [#{sub_style(hint.to_s, style.is_a?(Symbol) ? theme[style] : style)}]", default, **kwargs)
-        end
-
-        def confirm_outdated(pkg, ver, type, cur = nil, lock: false, col0: 0, col1: 0, col2: nil, col3: 0, col4: 0,
-                             **kwargs)
-          h = sub_style(semrev(type).upcase, (type == 1 && theme[:major]) || theme[:header])
-          case col0
-          when 0
-            col0 = "#{h}: "
-          when Numeric
-            puts h
-            col0 = ' ' * col0
-          else
-            puts h
-          end
-          b = sub_style pkg.ljust(col1), theme[:inline]
-          cur ||= 'locked' if lock
-          c = if cur
-                cur = cur.ljust(col2 || cur.size.succ)
-                lock ? sub_style(cur, color(:red)) : cur
-              end
-          d = type == 1 || lock ? 'N' : 'Y'
-          e = "#{col0}#{b}#{c}#{sub_style(col1 > 0 ? ver.ljust(col3) : ver.rjust(ver.size.succ), theme[:inline])}"
-          confirm("#{e}#{col4 > 0 ? ' ' * [col4 - e.stripstyle.size - 1, 2].max : '  '}", d, **kwargs)
+        def confirm_basic(msg, target, default = 'Y', style: :inline, **kwargs)
+          confirm("#{msg} [#{sub_style(target.to_s, style.is_a?(Symbol) ? theme[style] : style)}]", default, **kwargs)
         end
 
         def confirm_semver(msg, type, style: (type == 1 && theme[:major]) || :inline, timeout: 0, **kwargs)
-          confirm_basic(msg, semrev(type), type == 1 ? 'N' : 'Y', style: style, timeout: timeout, **kwargs)
+          rev = case type
+                when 1
+                  'major'
+                when 2
+                  'minor'
+                else
+                  'patch'
+                end
+          confirm_basic(msg, rev, type == 1 ? 'N' : 'Y', style: style, timeout: timeout, **kwargs)
         end
 
         def choice_index(msg, list, values: nil, accept: nil, series: false, trim: nil, column: nil, multiple: false,
                          force: true, **kwargs)
           puts unless series || printfirst?
-          ret = choice(msg, list, multiple: multiple, force: force, **kwargs).tap do |val|
-            next unless !val || val.empty?
-
+          ret = choice(msg, list, multiple: multiple, force: force, **kwargs)
+          unless ret && !ret.empty?
             exit 1 if force
-            return nil
+            return
           end
-          ret = multiple ? ret.map! { |val| val.sub(trim, '') } : ret.sub(trim, '') if trim
+          ret = multiple ? ret.map { |val| val.sub(trim, '') } : ret.sub(trim, '') if trim
           if column
             a, b = Array(column)
-            ret = Array(ret).map! { |val| val[a, b || 1] }
+            ret = Array(ret).map { |val| val[a, b || 1] }
             ret = ret.first unless multiple
           end
           if accept
             hint = Array(ret).map { |val| sub_style(val.to_s, theme[:inline]) }.join(', ')
             accept = Array(accept).map { |val| Array(val) }
-            if accept.any? { |val| val[1] == true }
-              ret = [ret]
-              multiple = -1
-            end
-            loop do
-              item = accept.first
+            ret = Array(ret) if accept.any? { |val| val[1] == true }
+            begin
+              item = accept.shift
               c = confirm("#{item[0]}#{" [#{hint}]" if hint}", item[2] ? 'Y' : 'N')
               if item[1] == true
                 ret << c
               elsif !c
-                break
+                exit 1
               end
               hint = nil
-              accept.shift
-              break if accept.empty?
-            end
-            exit 1 unless accept.empty?
+            end until accept.empty?
           end
           if values
-            ret = [ret] unless accept && multiple == -1
+            ret = Array(ret)
             Array(values).each do |val|
               if val.is_a?(Array)
                 val, force = val
@@ -2006,7 +2071,7 @@ module Squared
                 force = false
               end
               val = readline(val, force: force)
-              ret << (val unless val.empty?)
+              ret << (val.empty? ? nil : val)
             end
           end
           printsucc unless series
@@ -2024,10 +2089,11 @@ module Squared
         def command_args(args, min: 0, force: false, **kwargs)
           return if args.size > min || option('i', 'interactive', **kwargs, equals: '0')
 
-          readline('Enter arguments', force: force)
+          ret = readline('Enter arguments', force: force)
+          args << ret unless ret.empty?
         end
 
-        def block_args(fallback = nil, &blk)
+        def block_args(fallback = [], &blk)
           return fallback if (ret = instance_eval(&blk)).nil?
 
           Array(ret)
@@ -2046,49 +2112,40 @@ module Squared
           if workspace.powershell?
             "#{shell_bin('powershell.exe')} -Command \"& {#{args.join(' ; ')}}\"#{out}"
           else
-            args.map! { |val| "#{val}#{out}" }.join(' && ')
+            args.map { |val| "#{val}#{out}" }.join(' && ')
           end
         end
 
         def relativepath(*list, all: false)
-          list.flatten.map! { |val| Pathname.new(val) }.select { |val| projectpath?(val) }.map! do |val|
-            ret = (val.absolute? ? val.relative_path_from(path) : val.cleanpath).to_s
-            all && val.to_s.end_with?('/') ? "#{ret}/*" : ret
-          end
+          list.map { |val| Pathname.new(val) }
+              .select { |val| projectpath?(val) }
+              .map do |val|
+                ret = (val.absolute? ? val.relative_path_from(path) : val.cleanpath).to_s
+                all && val.to_s.end_with?('/') ? "#{ret}/*" : ret
+              end
         end
 
-        def projectmap(files, parent: false, pass: true)
+        def projectmap(files, resolve: true, parent: false, pass: true)
           unless parent
-            proj = files.select { |val| projectpath?(val) }
-            raise_error 'pathspec not within worktree' unless pass || files.size == proj.size
-            files = proj
-          end
-          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val)) }
-        end
-
-        def matchmap(list, prefix = nil, negate: false)
-          ret = negate ? [[], []] : []
-          list.each do |val|
-            unless val.is_a?(Regexp)
-              val = val.dup
-              n = 1 if negate && val.delete_prefix!('!')
-              if prefix
-                a = nil
-                val.sub!(/\A(\^|\\A)/) do |s|
-                  a = s
-                  nil
-                end
-                val = ".*#{val}" unless a
-              end
+            files = files.select { |val| projectpath?(val) }.tap do |list|
+              next if pass || files.size == list.size
+
+              raise_error 'pathspec not within worktree'
             end
-            pat = Regexp.new("#{a}#{prefix}#{val == '*' ? '.+' : val}")
-            if negate
-              ret[n || 0] << pat
+          end
+          files.map do |val|
+            if val == '.'
+              '.'
             else
-              ret << pat
+              val = basepath(val)
+              val = val.relative_path_from(path) unless resolve
+              shell_quote val
             end
           end
-          ret
+        end
+
+        def symjoin(*args, char: ':')
+          args.join(char).to_sym
         end
 
         def semver(val)
@@ -2113,11 +2170,11 @@ module Squared
           return -1 if (b = other.scan(SEM_VER)).empty?
           return 1 if (a = val.scan(SEM_VER)).empty?
 
-          a, b = [a.first, b.first].map! do |c|
+          a, b = [a.first, b.first].map do |c|
             d = begin
-              Integer(c[6]).to_s
-            rescue StandardError
-              c[6] ? '-1' : '0'
+              Integer(c[5]).to_s
+            rescue
+              c[5] ? '-1' : '0'
             end
             [c[0], c[2], c[4] || '0', d]
           end
@@ -2154,24 +2211,13 @@ module Squared
         end
 
         def semtype(cur, lat)
-          if semmajor?(cur, lat)
-            1
-          else
-            cur[2] == lat[2] ? 3 : 2
-          end
+          return 1 if semmajor?(cur, lat)
+
+          cur[2] == lat[2] ? 3 : 2
         end
 
-        def semrev(type)
-          case type
-          when 1
-            'major'
-          when 2
-            'minor'
-          when 3
-            'patch'
-          else
-            'unknown'
-          end
+        def semmajor?(cur, want)
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
         def semgte?(val, other = nil)
@@ -2197,7 +2243,7 @@ module Squared
         def shortname(*args, suffix: '?', delim: ',', pass: false)
           return unless TASK_METADATA || pass
 
-          args.map! do |ch|
+          args.map do |ch|
             "#{ch}/#{case ch
                      when 'i'
                        'nteractive'
@@ -2223,7 +2269,7 @@ module Squared
         end
 
         def color(val)
-          (ret = theme[val]) && !ret.empty? ? ret : [val]
+          (ret = Array(theme[val])).empty? ? [val] : ret
         end
 
         def colormap(val)
@@ -2232,7 +2278,7 @@ module Squared
 
         def verbosetype
           case verbose
-          when TrueClass
+          when true
             1
           when Numeric
             verbose.succ
@@ -2242,9 +2288,15 @@ module Squared
         end
 
         def on(event, from, *args, **kwargs)
-          return unless from && @events.key?(event)
+          return unless from && @on[:event].key?(event)
 
-          Array(@events[event][from]).each do |obj|
+          case event
+          when :first
+            @on[:from] << from
+          when :last
+            return unless @on[:from].delete(from)
+          end
+          Array(@on[:event][event][from]).each do |obj|
             target, opts = if obj.is_a?(Array) && obj[1].is_a?(Hash)
                              [obj[0], kwargs.empty? ? obj[1] : obj[1].merge(kwargs)]
                            else
@@ -2261,35 +2313,58 @@ module Squared
           end
         end
 
-        def on_error(err, from, pass: false, exception: self.exception, dryrun: false)
+        def on_error(err, from = @on[:from].last, exception: exception?, fatal: true, dryrun: false, pass: false)
           log&.error err
-          unless dryrun
-            ret = on :error, from, err
-            raise err if exception && ret != true
+          unless from == false
+            cancel = -> { @on[:from] = [false] if fatal && @on[:from].include?(from) }
+            if dryrun
+              cancel.call
+            else
+              ret = on :error, from, err
+              unless ret == true
+                cancel.call
+                raise err if exception
+              end
+            end
           end
           print_error(err, pass: pass) unless ret
         end
 
-        def pwd_set(pass: false, exception: self.exception, dryrun: false, from: nil)
-          return yield if (path.to_s == Dir.pwd || pass == true) && (workspace.mri? || !workspace.windows?)
+        def pwd_set(cmd = nil, pass: false, timeout: nil, from: @on[:from].last, **kwargs, &blk)
+          return if from == false
 
-          pwd = Dir.pwd
-          Dir.chdir(path)
-          yield
-        rescue StandardError => e
-          on_error(e, from, exception: exception, dryrun: dryrun)
+          require 'timeout'
+          unless (path.to_s == Dir.pwd || pass == true) && (workspace.mri? || !workspace.windows?)
+            pwd = Dir.pwd
+            Dir.chdir(path)
+          end
+          timeout = session_timeout cmd if cmd && timeout.nil?
+          if timeout.to_f > 0
+            Timeout.timeout(timeout, &blk)
+          else
+            yield
+          end
+        rescue Timeout::Error => e
+          if cmd
+            print_error(Logger::ERROR, cmd, subject: name, hint: e)
+          else
+            print_error(Logger::ERROR, e, subject: name)
+          end
+          exit 1 unless exception?(Logger::DEBUG, Logger::INFO)
+        rescue => e
+          on_error(e, from, **kwargs)
         ensure
           Dir.chdir(pwd) if pwd
         end
 
-        def run_set(cmd, val = nil, opts: nil, global: false, **)
+        def run_set(cmd, val = nil, opts: nil, global: nil, **)
           noopt = @output[1] == false && !@output[0].nil?
           noenv = @output[2] == false
           parse = lambda do |data|
             ret = []
             if data[:command]
               ret[0] = data[:command]
-              ret[1] = data[:opts] unless noopt
+              ret[1] = data[:opts] unless diso
               ret[3] = data[:args]
             elsif data[:script]
               ret[1] = data[:script]
@@ -2298,15 +2373,22 @@ module Squared
             else
               ret[0] = false
             end
-            ret[2] = data[:env] unless noenv
+            ret[2] = data[:env] unless dise
             ret
           end
-          self.global = global
+          case global
+          when true
+            self.global = 1
+          when false
+            self.global = -1
+          when Numeric
+            self.global = 1 | global
+          end
           case cmd
           when Hash
             @output = parse.call(data)
           when Enumerable
-            @output = if cmd.all?(Hash)
+            @output = if cmd.all? { |data| data.is_a?(Hash) }
                         noopt = false
                         noenv = false
                         cmd.map { |data| parse.call(data) }
@@ -2333,12 +2415,19 @@ module Squared
           end
         end
 
-        def script_set(cmd, prod: nil, args: nil, global: false, **)
+        def script_set(cmd, prod: nil, args: nil, global: nil, **)
           return if @output[1] == false && @output[0].nil?
 
-          self.global = global
+          case global
+          when true
+            self.global = 2
+          when false
+            self.global = -2
+          when Numeric
+            self.global = 2 | global
+          end
           @output[0] = nil
-          @output[1] = if self.global && cmd.is_a?(Array)
+          @output[1] = if global && cmd.is_a?(Array)
                          cmd[prod == true ? 1 : 0]
                        else
                          cmd
@@ -2360,6 +2449,15 @@ module Squared
                    end
         end
 
+        def timeout_set(val)
+          case val
+          when Hash
+            @timeout.update(val)
+          when Numeric
+            @timeout[:_][2] = val
+          end
+        end
+
         def pass_set(val)
           @pass = Array(val).freeze
         end
@@ -2398,23 +2496,17 @@ module Squared
                    end
         end
 
-        def dependfile_set(list, default: 0)
+        def dependfile_set(list)
           @dependindex = if @dependname
                            @dependfile = basepath @dependname
                            list.index(@dependname)
                          else
-                           list.index { |file| exist?(file) }.tap { |i| @dependfile = basepath(list[i || default]) }
-                         end || (list unless enabled?)
-        end
-
-        def dependindex
-          dependfile_set @dependindex if @dependindex.is_a?(Array)
-
-          @dependindex unless @dependindex.is_a?(Array)
+                           list.index { |file| exist?(file) }.tap { |i: 0| @dependfile = basepath(list[i]) }
+                         end
         end
 
-        def as_get(val, from)
-          (global && @as[from][val]) || val
+        def as_get(val, from, *type)
+          (global(*type) && @as[from][val]) || val
         end
 
         def unpack_get(*)
@@ -2437,7 +2529,7 @@ module Squared
               next if (items = children.select { |item| item.task_include?(key) }).empty?
 
               ws.task_desc(@desc, action, 'workspace')
-              task task_join(action, 'workspace') => items.map! { |item| task_join(item.name, action) }
+              task task_join(action, 'workspace') => items.map { |item| task_join(item.name, action) }
             end
           end
         end
@@ -2446,10 +2538,6 @@ module Squared
           @only ? !@only.include?(key) : @pass.include?(key)
         end
 
-        def matchany?(val, list, empty: true)
-          list.empty? ? empty : list.any? { |pat| val.match?(pat) }
-        end
-
         def projectpath?(val)
           ret = Pathname.new(val).cleanpath
           ret.absolute? ? ret.to_s.start_with?(File.join(path, '')) : !ret.to_s.start_with?(File.join('..', ''))
@@ -2462,10 +2550,6 @@ module Squared
           false
         end
 
-        def semmajor?(cur, want)
-          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[6]
-        end
-
         def printfirst?
           @@print_order == 0
         end
@@ -2507,30 +2591,24 @@ module Squared
         end
 
         def success?(run, *cond)
-          case run
-          when TrueClass
-            true
-          when FalseClass
-            false
-          else
-            $?&.success?
-          end.tap do |ret|
-            next unless cond.none? { |val| val == false }
-
+          ret = case run
+                when true, false
+                  run
+                else
+                  $?.success?
+                end
+          if cond.none? { |val| val == false }
             if block_given?
               yield ret
             elsif ret && stdout? && banner?
               print_success
             end
           end
+          ret
         end
 
         def banner?
-          ARG[:BANNER] && !env('BANNER', equals: '0')
-        end
-
-        def dryrun?(*, target: @session, prefix: target&.first)
-          Array(target).include?('--dry-run') || !option('dry-run', target: target, prefix: prefix).nil?
+          ARG[:BANNER] && env('BANNER', notequals: '0')
         end
 
         def pwd?
@@ -2542,7 +2620,7 @@ module Squared
         end
 
         def stdout?
-          !silent? && !stdin?
+          !!verbose && !stdin?
         end
 
         def verbose?
@@ -2557,29 +2635,9 @@ module Squared
           workspace.warning
         end
 
-        def has_value?(target, *args)
-          return false unless target.is_a?(Enumerable)
-
-          args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
-          args.any? { |obj,| target.include?(obj) }
-        end
-
-        def has_value!(target, *args, first: false)
-          return unless target.is_a?(Enumerable)
-
-          args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
-          found = false
-          args.each do |val|
-            if target.respond_to?(:delete?)
-              found = true if target.delete?(val)
-            elsif target.respond_to?(:delete)
-              found = true if target.delete(val)
-            elsif target.include?(val)
-              found = true
-            end
-            break if found && first
-          end
-          target if found
+        def exception?(*level)
+          ex = exception
+          level.empty? ? ex != false && ex != Logger::INFO : ex.is_a?(Numeric) && level.include?(ex)
         end
 
         def variables
@@ -2599,12 +2657,13 @@ module Squared
         end
 
         def scriptargs
-          { target: script? ? @output[1] : @output[0], script: script?, ref: ref, group: group, global: global }
+          n = script? ? 1 : 0
+          { target: @output[n], type: n == 1 ? :script : :run, ref: ref, group: group, global: global(n.succ) }
         end
       end
 
-      Application.implement(Base, base: true)
-      Application.attr_banner = Set.new(%i[name project path ref group parent])
+      Application.implement Base, base: 0
+      Application.attr_banner.merge(%i[name project path ref group parent])
     end
   end
 end