squared 0.5.20 → 0.6.0

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

@@ -5,38 +5,41 @@ module Squared
     module Project
       class Node < Git
         OPT_NPM = {
-          common: %w[dry-run=!? include-workspace-root=!? loglevel=b workspaces=!? w|workspace=v].freeze,
-          install: %w[package-lock-only=!? prefer-dedupe=!? E|save-exact=!? before=q cpu=b libc=b os=b].freeze,
-          install_base: %w[audit=! bin-links=! foreground-scripts=!? fund=! ignore-scripts=!? install-links=!?
-                           package-lock=! strict-peer-deps=!? include=b install-strategy=b omit=b].freeze,
-          install_no: %w[audit bin-links fund package-lock].freeze,
-          install_as: %w[no-save B|save-bundle D|save-dev O|save-optional save-peer P|save-prod g|global=!?
-                         S|save=!?].freeze,
+          common: %w[dry-run=!? loglevel=b include-workspace-root=!? workspaces=!? w|workspace=v].freeze,
+          install: %w[package-lock-only=!? prefer-dedupe=!? cpu=b libc=b os=b].freeze,
+          install_a: %w[audit=! bin-links=! fund=! ignore-scripts=!? install-links=!? package-lock=! strict-peer-deps=!?
+                        include=b install-strategy=b omit=b].freeze,
+          install_b: %w[no-save save-bundle save-dev save-optional save-peer save-prod before=q foreground-scripts=!?
+                        g|global=!? S|save=!? E|save-exact=!?].freeze,
           run: %w[foreground-scripts=!? if-present=!? ignore-scripts=!? script-shell=p].freeze,
           exec: %w[c|call=q package=b].freeze,
-          pack: %w[ignore-scripts=!? json=!? pack-destination=p].freeze
+          pack: %w[ignore-scripts=!? json=!? pack-destination=p].freeze,
+          no: {
+            install: %w[audit bin-links fund package-lock].freeze
+          }.freeze
         }.freeze
         OPT_PNPM = {
-          common: %w[aggregate-output color ignore-workspace-root-check no-color stream use-stderr C|dir=p loglevel=b
-                     r|recursive w|workspace-root].freeze,
-          cpu: %w[cpu=b libc=b os=b].freeze,
-          filter: %w[fail-if-no-match changed-files-ignore-pattern=q filter=q filter-prod=q test-pattern=q].freeze,
+          common: %w[aggregate-output color no-color stream use-stderr C|dir=p loglevel=b w|workspace-root].freeze,
+          common_cpu: %w[cpu=b libc=b os=b].freeze,
+          common_filter: %w[fail-if-no-match changed-files-ignore-pattern=q filter=q filter-prod=q
+                            test-pattern=q].freeze,
           install: %w[fix-lockfile force ignore-pnpmfile ignore-workspace lockfile-only merge-git-branch-lockfiles
                       optimistic-repeat-install no-hoist no-lockfile no-optional prefer-frozen-lockfile resolution-only
                       shamefully-hoist side-effects-cache side-effects-cache-readonly s|silent strict-peer-dependencies
                       use-running-store-server use-store-server child-concurrency=i hoist-pattern=q lockfile-dir=p
                       modules-dir=p network-concurrency=i package-import-method=b public-hoist-pattern=q
                       reporter=b].freeze,
-          install_base: %w[dangerously-allow-all-builds global-dir ignore-scripts offline prefer-offline store-dir=p
-                           virtual-store-dir=p].freeze,
-          install_no: %w[frozen-lockfile verify-store-integrity].freeze,
-          install_as: %w[D|dev no-optional P|prod].freeze,
+          install_a: %w[global-dir ignore-scripts offline prefer-offline store-dir=p virtual-store-dir=p].freeze,
+          install_b: %w[D|dev global-dir no-optional P|prod r|recursive].freeze,
           update: %w[g|global i|interactive L|latest depth=i].freeze,
           dedupe: %w[check].freeze,
-          run: %w[if-present no-bail parallel report-summary reporter-hide-prefix resume-from
+          run: %w[if-present no-bail parallel r|recursive report-summary reporter-hide-prefix resume-from
                   sequential].freeze,
-          exec: %w[no-reporter-hide-prefix parallel report-summary resume-from c|shell-mode].freeze,
-          pack: %w[json pack-destination=p pack-gzip-level=i].freeze
+          exec: %w[no-reporter-hide-prefix parallel r|recursive report-summary resume-from c|shell-mode].freeze,
+          pack: %w[json r|recursive pack-destination=p pack-gzip-level=i out=p workspace-concurrency=i].freeze,
+          no: {
+            install: %w[frozen-lockfile verify-store-integrity].freeze
+          }.freeze
         }.freeze
         OPT_YARN = {
           common: %w[check-files disable-pnp enable-pnp flat focus force frozen-lockfile json har ignore-engines
@@ -58,11 +61,45 @@ module Squared
           run: %w[B|binaries-only inspect inspect-brk T|top-level require=q].freeze,
           pack: %w[n|dry-run install-if-needed json o|out=p].freeze
         }.freeze
-        private_constant :OPT_NPM, :OPT_PNPM, :OPT_YARN, :OPT_BERRY
+        OPT_TSC = {
+          base: %w[all b|build init listFilesOnly locale=b p|project=p showConfig w|watch].freeze,
+          compiler: %w[allowArbitraryExtensions=!? allowImportingTsExtensions=!? allowJs=!?
+                       allowSyntheticDefaultImports=!? allowUmdGlobalAccess=!? allowUnreachableCode=!?
+                       allowUnusedLabels=!? alwaysStrict=!? assumeChangesOnlyAffectDirectDependencies=!? baseUrl=p
+                       charset=b checkJs=!? composite=!? customConditions=q d|declaration=!? declarationDir=p
+                       declarationMap=!? diagnostics=!? disableReferencedProjectLoad=!? disableSizeLimit=!?
+                       disableSolutionSearching=!? downlevelIteration=!? emitBOM=!? emitDeclarationOnly=!?
+                       emitDecoratorMetadata=!? erasableSyntaxOnly=!? esModuleInterop=!? exactOptionalPropertyTypes=!?
+                       experimentalDecorators=!? explainFiles=!? extendedDiagnostics=!?
+                       forceConsistentCasingInFileNames=!? generateCpuProfile=b importHelpers=!?
+                       importsNotUsedAsValues=b incremental=!? inlineSourceMap=!? inlineSources=!?
+                       isolatedDeclarations=!? isolatedModules=!? jsx=b jsxFactory=q jsxFragmentFactory=q
+                       jsxImportSource=q keyofStringsOnly=!? lib=q libReplacement=!? listEmittedFiles=!? listFiles=!?
+                       mapRoot=p maxNodeModuleJsDepth=i m|module=b moduleDetection=b moduleResolution=b moduleSuffixes=b
+                       newLine=b noCheck=!? noEmit=!? noEmitHelpers=!? noEmitOnError=!? noErrorTruncation=!?
+                       noFallthroughCasesInSwitch=!? noImplicitAny=!? noImplicitOverride=!? noImplicitReturns=!?
+                       noImplicitThis=!? noImplicitUseStrict=!? noLib=!? noPropertyAccessFromIndexSignature=!?
+                       noResolve=!? noStrictGenericChecks=!? noUncheckedIndexedAccess=!? noUncheckedSideEffectImports=!?
+                       noUnusedLocals=!? noUnusedParameters=!? outDir=p outFile=p paths=q plugins=b
+                       preserveConstEnums=!? preserveSymlinks=!? preserveValueImports=!? preserveWatchOutput=!?
+                       pretty=!? reactNamespace=b removeComments=!? resolveJsonModule=!? resolvePackageJsonExports=!?
+                       resolvePackageJsonImports=!? rewriteRelativeImportExtensions=!? rootDir=p rootDirs=p
+                       skipDefaultLibCheck=!? skipLibCheck=!? sourceMap=!? sourceRoot=p stopBuildOnErrors=!? strict=!?
+                       strictBindCallApply=!? strictBuiltinIteratorReturn=!? strictFunctionTypes=!? strictNullChecks=!?
+                       strictPropertyInitialization=!? stripInternal=!? suppressExcessPropertyErrors=!?
+                       suppressImplicitAnyIndexErrors=!? t|target=b traceResolution=!? tsBuildInfoFile=p typeRoots=p
+                       types=b useDefineForClassFields=!? useUnknownInCatchVariables=!? verbatimModuleSyntax=!?].freeze,
+          build: %w[clean=!? dry=!? force=!? v|verbose=!?].freeze,
+          watch: %w[excludeDirectories=p excludeFiles=p fallbackPolling=b synchronousWatchDirectory=!? watchDirectory=b
+                    watchFile=b].freeze
+        }.freeze
+        PASS_NODE = {
+          tsc: %w[excludeDirectories excludeFiles customConditions lib moduleSuffixes plugins rootDirs typeRoots
+                  types].freeze
+        }.freeze
+        private_constant :OPT_NPM, :OPT_PNPM, :OPT_YARN, :OPT_BERRY, :OPT_TSC, :PASS_NODE
 
         class << self
-          def populate(*); end
-
           def tasks
             %i[outdated update publish].freeze
           end
@@ -91,10 +128,11 @@ module Squared
         end
 
         subtasks({
-          'package' => %i[install dedupe update].freeze,
+          'package' => %i[install reinstall dedupe update].freeze,
           'outdated' => %i[major minor patch].freeze,
           'bump' => %i[version major minor patch].freeze,
           'publish' => %i[latest tag].freeze,
+          'tsc' => %i[project build].freeze,
           'add' => nil,
           'run' => nil,
           'exec' => nil,
@@ -102,7 +140,7 @@ module Squared
           'pack' => nil
         })
 
-        def initialize(*, init: nil, asdf: 'nodejs', **kwargs)
+        def initialize(*, init: nil, ts: 'tsconfig.json', asdf: 'nodejs', **kwargs)
           super
           if @pass.include?(Node.ref)
             initialize_ref Node.ref
@@ -111,7 +149,9 @@ module Squared
             initialize_build(Node.ref, prod: prod?, **kwargs)
             initialize_env(**kwargs)
           end
-          @dependfile = basepath 'package.json'
+          @dependname = 'package.json'
+          dependfile_set [@dependname]
+          @tsfile = basepath(ts).yield_self { |file| file if file.exist? }
           @pm = { __: init }
         end
 
@@ -156,13 +196,12 @@ module Squared
                       opts = []
                       args.each do |val|
                         if (n, extra = indexitem(val))
-                          if (item = list[n - 1])
+                          if (item = list[n.pred])
                             run compose([item.first, extra].compact.join(' '), script: true)
                           elsif exception
                             indexerror n, list
                           else
-                            log.warn "run script #{n} of #{list.size} (out of range)"
-                            next
+                            next log.warn "run script #{n} of #{list.size} (out of range)"
                           end
                         else
                           opts << val
@@ -173,13 +212,13 @@ module Squared
                       list = if (yarn = dependtype(:yarn)) > 0
                                yarn == 1 ? OPT_YARN[:run] + OPT_YARN[:common] : OPT_BERRY[:run]
                              elsif pnpm?
-                               OPT_PNPM[:run] + OPT_PNPM[:filter] + OPT_PNPM[:common]
+                               pnpmopts :run, :common_filter
                              else
-                               OPT_NPM[:run] + OPT_NPM[:common]
+                               npmopts :run
                              end
-                      op = OptionPartition.new(opts, list, session(dependbin, 'run'), project: self)
-                      op << op.extras.shift
-                      op.append(delim: true, quote: false)
+                      OptionPartition.new(opts, list, session(dependbin, 'run'), project: self)
+                                     .add_first
+                                     .append(delim: true, quote: false)
                       run(from: :run)
                     end
                   end
@@ -188,23 +227,23 @@ module Squared
                   task action, [:package] do |_, args|
                     if (package = args.package)
                       args = args.extras
-                      if pnpm?
-                        pre = ->(ch) { "-#{ch}" if (ch = args.delete(ch)) }
-                        cmd = session 'pnpm', pre.call('r'), pre.call('c'), 'exec'
-                        list = OPT_PNPM[:exec] + OPT_PNPM[:filter] + OPT_PNPM[:common]
-                      else
-                        cmd = session 'npm', 'exec'
-                        list = OPT_NPM[:exec] + OPT_NPM[:common]
-                      end
+                      cmd = if pnpm?
+                              pre = ->(ch) { "-#{ch}" if args.delete(ch) }
+                              list = pnpmopts :exec, :common_filter
+                              session 'pnpm', pre.call('r'), pre.call('c'), 'exec'
+                            else
+                              list = npmopts :exec
+                              session 'npm', 'exec'
+                            end
                       op = OptionPartition.new(args, list, cmd, project: self)
                       if op.empty?
                         op << package
                         if (args = readline('Enter arguments', force: false))
-                          op.delim unless pnpm?
+                          op << '--' unless pnpm?
                           op << args
                         end
                       else
-                        op.delim unless pnpm?
+                        op << '--' unless pnpm?
                         op << package << op.join(' ')
                       end
                     else
@@ -234,16 +273,22 @@ module Squared
                   flags.each do |flag|
                     case action
                     when 'outdated'
-                      format_desc(action, flag, %w[update interactive dry-run], arg: 'opts?')
+                      format_desc action, flag, %w[u/pdate s/elect i/nteractive d/ry-run diff]
                       task flag do |_, args|
                         outdated flag, args.to_a
                       end
                     when 'package'
-                      format_desc(action, flag, 'opts*', after: flag == :dedupe ? nil : 'name*')
+                      format_desc(action, flag, 'opts*', before: case flag
+                                                                 when :dedupe then nil
+                                                                 when :reinstall then 'force?'
+                                                                 else 'name*'
+                                                                 end)
                       task flag do |_, args|
                         package flag, args.to_a
                       end
                     when 'bump'
+                      break unless version
+
                       if flag == :version
                         format_desc action, flag, 'version'
                         task flag, [:version] do |_, args|
@@ -257,15 +302,16 @@ module Squared
                         end
                       end
                     when 'publish'
-                      format_desc(action, flag, 'otp?,dry-run?,public|restricted?', before: flag == :tag ? 'tag' : nil)
+                      format_desc(action, flag, 'otp?,d/ry-run?,p/ublic|r/estricted?',
+                                  before: ('tag' if flag == :tag))
                       task flag do |_, args|
                         args = args.to_a
                         dryrun = true if args.delete('dry-run') || args.delete('d')
-                        if args.delete('public') || args.delete('p')
-                          access = 'public'
-                        elsif args.delete('restricted') || args.delete('r')
-                          access = 'restricted'
-                        end
+                        access = if args.delete('public') || args.delete('p')
+                                   'public'
+                                 elsif args.delete('restricted') || args.delete('r')
+                                   'restricted'
+                                 end
                         if flag == :latest
                           otp = args.first
                         else
@@ -273,6 +319,22 @@ module Squared
                         end
                         publish(flag, otp: otp, tag: tag, dryrun: dryrun, access: access)
                       end
+                    when 'tsc'
+                      break unless @tsfile
+
+                      format_desc(action, flag, 'opts*', "#{flag == :project ? 'before' : 'after'}": 'config?')
+                      task flag do |_, args|
+                        args = args.to_a
+                        if flag == :project
+                          project = if !args.empty? && exist?(args.first)
+                                      args.shift
+                                    else
+                                      @tsfile
+                                    end
+                        end
+                        watch = !(args.delete('watch') || args.delete('w')).nil?
+                        tsc(*args, banner: true, project: project, build: flag == :build, watch: watch)
+                      end
                     end
                   end
                 end
@@ -283,8 +345,6 @@ module Squared
 
         def copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, files: nil, workspace: false,
                  link: false, force: false, override: false, sync: invoked_sync?('copy'), **kwargs)
-          return if @copy == false
-
           glob = kwargs[:include]
           pass = kwargs[:exclude]
           if @copy && !override
@@ -301,6 +361,8 @@ module Squared
             create = @copy[:create] if @copy.key?(:create)
             glob = @copy[:include] if @copy.key?(:include)
             pass = @copy[:exclude] if @copy.key?(:exclude)
+          elsif @copy == false
+            return
           end
           items = []
           if build? && path != @workspace.home && @workspace.home?
@@ -322,13 +384,13 @@ module Squared
               dest = @workspace.root + dir
               @workspace.rev_clear(dest, sync: sync)
             when Symbol
-              if (proj = @workspace.find(name: dir))
-                @workspace.rev_clear(proj.name, sync: sync)
-                dest = proj.path
-              else
-                log.warn message("copy project :#{dir}", hint: 'not found')
-                dest = nil
-              end
+              dest = if (proj = @workspace.find(name: dir))
+                       @workspace.rev_clear(proj.name, sync: sync)
+                       proj.path
+                     else
+                       log.warn message("copy project :#{dir}", hint: 'missing')
+                       nil
+                     end
             when Hash
               from = dir[:from] if dir.key?(:from)
               into = dir[:into] if dir.key?(:into)
@@ -346,7 +408,7 @@ module Squared
               dest = dir.path
               @workspace.rev_clear(dir.name, sync: sync)
             else
-              raise_error "copy: given #{dir}"
+              raise_error TypeError, "unknown: #{dir}", hint: 'copy'
             end
             next unless from && dest&.directory?
 
@@ -364,14 +426,14 @@ module Squared
                   .concat(Array(files))
                   packed = true
                 end
-                to = dest.join(into, npmname)
-                to.mkpath
-                log.info "cp npm:#{npmname} #{to}"
+                base = dest.join(into, npmname)
+                base.mkpath
+                log.info "cp npm:#{npmname} #{base}"
                 subdir = []
                 errors = 0
                 files.each do |file|
                   s, d = file.is_a?(Array) ? file : [file, file]
-                  dest = to + d
+                  dest = base + d
                   unless subdir.include?((target = dest.dirname).to_s)
                     target.mkpath
                     subdir << target.to_s
@@ -384,7 +446,7 @@ module Squared
               rescue StandardError => e
                 on_error e, :copy
               else
-                puts message(to, subdir.size, files.size - errors) if verbose
+                puts message(base, subdir.size, files.size - errors) if verbose
               end
               next
             end
@@ -397,20 +459,19 @@ module Squared
 
                 sub = if (proj = @workspace.find(entry))
                         proj.packagename
-                      elsif (file = entry + 'package.json').exist?
+                      elsif (file = entry + dependname).exist?
                         begin
                           doc = JSON.parse(file.read)
+                          doc['name']
                         rescue StandardError => e
                           log.error e
                           raise if exception
-                        else
-                          doc['name']
                         end
                       end
                 if sub
                   target << [entry, dest.join(into, sub)]
                 else
-                  log.debug message("package.json in \"#{entry}\"", hint: 'not found')
+                  log.debug message("#{dependname} in \"#{entry}\"", hint: 'missing')
                 end
               end
             else
@@ -433,6 +494,8 @@ module Squared
             workspace.rev_clear(name, sync: sync)
             return update if !flag && env('NODE_UPDATE')
 
+            ws = env('NODE_WORKSPACES', equals: '0')
+            ci = option('ci')
             if (yarn = dependtype(:yarn)) > 0
               cmd = session 'yarn'
               if flag == :add
@@ -442,72 +505,91 @@ module Squared
               else
                 cmd << 'install'
                 cmd << '--ignore-engines' if yarn == 1 && !option('ignore-engines', equals: '0')
+                cmd << (yarn == 1 ? '--force' : '--check-cache') if option('force')
+              end
+              if nolockfile?('yarn')
+                cmd << '--no-lockfile'
+              elsif ci
+                if yarn == 1
+                  cmd << '--frozen-lockfile'
+                else
+                  cmd << '--immutable' << '--refresh-lockfile'
+                end
               end
             elsif pnpm?
               cmd = session 'pnpm'
               if flag == :add
                 cmd << 'add' << "--save-#{save}"
                 cmd << '--save-exact' if exact
-                option('allow-build') { |val| cmd << quote_option('allow-build', val) }
               else
                 cmd << 'install'
                 append_platform
               end
-              option('public-hoist-pattern') do |val|
-                split_escape(val).each { |opt| cmd << shell_option('public-hoist-pattern', opt) }
+              option('public-hoist-pattern', ignore: false) do |val|
+                split_escape(val) { |opt| cmd << shell_option('public-hoist-pattern', opt) }
               end
-              cmd << '--ignore-workspace' if env('NODE_WORKSPACES', equals: '0')
-              cmd << '--dangerously-allow-all-builds' if option('approve-builds')
+              cmd << '--ignore-workspace' if ws
+              cmd << if option('force')
+                       '--force'
+                     elsif nolockfile?('pnpm')
+                       '--no-lockfile'
+                     elsif ci
+                       '--frozen-lockfile'
+                     end
               append_nocolor
             else
-              cmd = session 'npm', 'install'
-              if flag == :add
-                cmd << "--save-#{save}"
-                cmd << '--save-exact' if exact
+              cmd = session 'npm'
+              if ci
+                cmd << 'ci'
               else
-                append_platform
+                cmd << 'install'
+                if flag == :add
+                  cmd << "--save-#{save}"
+                  cmd << '--save-exact' if exact
+                  cmd.merge(packages.map { |pkg| shell_quote(pkg) })
+                else
+                  append_platform
+                end
               end
-              cmd << '--workspaces=false' if env('NODE_WORKSPACES', equals: '0')
-              cmd << '--package-lock=false' if option('package-lock', equals: '0')
+              cmd << '--workspaces=false' if ws
+              cmd << '--package-lock=false' << 'save=false' if nolockfile?('npm')
               append_nocolor
             end
             append_loglevel
-            cmd.merge(packages.map { |pkg| shell_quote(pkg) }) if flag == :add
-            run(from: flag || :depend, sync: sync)
+            run(from: :depend, sync: sync)
           end
         end
 
         def outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag))
-          dryrun = opts.include?('dry-run') || opts.include?('d')
-          if pnpm?
-            cmd = session 'pnpm', 'outdated'
-            dryrun ||= dryrun?('pnpm')
-          else
-            cmd = session 'npm', 'outdated'
-            dryrun ||= dryrun?('npm')
-          end
+          cmd = session(pnpm? ? 'pnpm' : 'npm', 'outdated')
+          dryrun = has_value?(opts, 'd', 'dry-run') || dryrun?
           unless dryrun
             log.info cmd.to_s
             on :first, :outdated
           end
-          banner = format_banner(cmd.temp(dryrun ? '--dry-run' : nil))
+          banner = format_banner(cmd.temp(('--dry-run' if dryrun)))
           print_item banner if sync
           begin
-            data = pwd_set(dryrun: dryrun) { `#{cmd.temp('--json', '--loglevel=error')}` }
+            data = pwd_set(dryrun: dryrun) { `#{cmd.temp('--json --loglevel=error')}` }
             doc = dependfile.read
             json = JSON.parse(doc)
-          rescue StandardError => e
-            on_error(e, :outdated, dryrun: dryrun)
-            return
-          else
             dep1 = json['dependencies'] || {}
             dep2 = json['devDependencies'] || {}
             target = json['name']
+          rescue StandardError => e
+            on_error(e, :outdated, dryrun: dryrun)
+            return
           end
           found = []
           avail = []
           rev = flag || (prod? ? :patch : :minor)
-          inter = opts.include?('interactive') || opts.include?('i')
+          if sync && !stdin?
+            if has_value?(opts, 's', 'select') && !dryrun
+              items = []
+            elsif has_value?(opts, 'i', 'interactive')
+              ia = true
+            end
+          end
           unless data.empty?
             JSON.parse(data).each_pair do |key, val|
               val = val.find { |obj| obj['dependent'] == target } if val.is_a?(Array)
@@ -517,7 +599,7 @@ module Squared
               ch = file[0]
               if ch.match?(/[~^]/)
                 file = file[1..-1]
-              elsif inter && rev == :major
+              elsif ia && rev == :major
                 major = true
               else
                 avail << [key, file, latest, true]
@@ -545,14 +627,14 @@ module Squared
               b = f[2]
               c = w[0]
               d = w[2]
-              case rev
-              when :major
-                upgrade = a == '0' ? c == '0' || c == '1' : true
-              when :minor
-                upgrade = ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
-              when :patch
-                upgrade = a == c && b == d && f[4] != w[4]
-              end
+              upgrade = case rev
+                        when :major
+                          a == '0' ? c == '0' || c == '1' : true
+                        when :minor
+                          ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
+                        when :patch
+                          a == c && b == d && f[4] != w[4]
+                        end
               if upgrade && !w[5]
                 next if file == want
 
@@ -570,7 +652,7 @@ module Squared
           end
           pending = 0
           modified = 0
-          size_col = ->(items, i) { items.map { |a| a[i] }.max_by(&:size).size }
+          size_col = ->(a, i) { a.map { |aa| aa[i] }.max_by(&:size).size }
           pad_ord = lambda do |val, ord|
             ret = val.succ.to_s
             ord.size > 9 ? ret.rjust(ord.size.to_s.size) : ret
@@ -590,52 +672,86 @@ module Squared
           if !found.empty?
             col1 = size_col.call(found, 0) + 4
             col2 = size_col.call(found, 1) + 4
+            packages = []
+            pat = ->(a) { /("#{Regexp.escape(a[0])}"\s*:\s*)"([~^])#{a[4] ? '?' : ''}#{Regexp.escape(a[1])}"/ }
+            edit = lambda do |a, pkg, mod|
+              packages << a[0]
+              modified += 1
+              "#{pkg}\"#{mod || (a[3] == 1 && a[4] ? '^' : '')}#{a[2]}\""
+            end
             found.each_with_index do |item, i|
               a, b, c, d, e = item
-              f = inter && (rev != :major || e || semmajor?(item[5], item[6]))
-              if f && !confirm_outdated(a, c, (d / 2.0).ceil, b, lock: e, col1: col1)
+              f = ia && (rev != :major || e || semmajor?(item[5], item[6]))
+              if f && !confirm_outdated(a, c, (d / 2.0).ceil, b, lock: e, col1: col1, timeout: 0)
                 cur = -1
               else
                 cur = modified
-                doc.sub!(/("#{Regexp.escape(a)}"\s*:\s*)"([~^])#{e ? '?' : ''}#{Regexp.escape(b)}"/) do |capture|
+                doc.send(items ? :sub : :sub!, pat.call(item)) do |capture|
                   if $2 == '~' && rev != :patch
                     cur = -1
                     pending += 1
                     capture
                   else
-                    modified += 1
-                    "#{$1}\"#{$2 || (d == 1 && e ? '^' : '')}#{c}\""
+                    edit.call(item, $1, $2)
                   end
                 end
               end
               a = a.ljust(col1)
               b = b.ljust(col2)
-              b = sub_style(b, styles: theme[:current]) if theme[:current]
+              b = sub_style(b, styles: theme[:current]) if theme[:current] && !stdin?
               c = if cur == -1
                     'SKIP'
                   elsif modified == cur
                     'FAIL'
-                  elsif d == 1
-                    a = sub_style(a, styles: theme[:major])
-                    sub_style(c, :bold, styles: color(:green))
+                  elsif stdin?
+                    c
                   else
-                    sub_style(c, pat: SEM_VER, styles: color(d == 3 ? :green : :yellow), index: d)
+                    g = item
+                    if d == 1
+                      a = sub_style(a, styles: theme[:major])
+                      sub_style(c, :bold, styles: color(:green))
+                    else
+                      sub_style(c, **opt_style(color(d == 3 ? :green : :yellow), SEM_VER, d))
+                    end
                   end
-              puts "#{pad_ord.call(i, found)}. #{a + b + c}"
+              s = a + b + c
+              if !items
+                puts "#{pad_ord.call(i, found)}. #{s}"
+              elsif g
+                items << [s, g]
+              end
             end
             pending = avail.reduce(pending) { |a, b| a + (b[3] ? 0 : 1) }
-            if dryrun || (modified == 0 && pending > 0)
-              footer.call(modified, found.size)
+            if dryrun || (modified == 0 && (pending > 0 || (items && pending == 0)))
+              n = if items
+                    puts(items.empty? ? 'No updates were found' : items.map(&:first))
+                    items.size
+                  else
+                    found.size
+                  end
+              footer.call(modified, n) unless n == 0
             elsif modified > 0
-              modified = -1
-              File.write(dependfile, doc)
-              if opts.include?('update') || opts.include?('u') || option('update')
-                update
-              else
-                footer.call(0, found.size)
+              if items
+                packages.clear
+                choice('Select a package', items.map(&:first), multiple: true, force: false, index: true, border: true)
+                  .each do |n|
+                    item = items[n.pred].last
+                    doc.sub!(pat.call(item)) { edit.call(item, $1, $2) }
+                  end
+              end
+              unless packages.empty?
+                File.write(dependfile, doc)
+                if sync && (opts.include?('diff') || option('diff'))
+                  run(git_output('diff', shell_quote(dependfile)), banner: false)
+                end
+                if has_value?(opts, 'u', 'update') || option('update')
+                  package(:update, packages: packages, from: :'outdated:update')
+                else
+                  modified = -1
+                  footer.call(0, found.size)
+                end
+                commit(:add, [dependname], pass: true)
               end
-              printsucc
-              commit(:add, ['package.json'], pass: true)
             end
           elsif !avail.empty?
             col1 = size_col.call(avail, 0) + 4
@@ -651,7 +767,7 @@ module Squared
                 c = sub_style(c, styles: color(:green))
                 pending += 1
               end
-              puts "#{pad_ord.call(i, avail)}. #{a + c + b} (#{d ? 'locked' : 'latest'})"
+              puts "#{pad_ord.call(i, avail)}. #{(a + c + b).subhint(d ? 'locked' : 'latest')}"
             end
             footer.call(0, avail.size)
           else
@@ -665,10 +781,17 @@ module Squared
         end
 
         def publish(flag = nil, *, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, access: nil, dryrun: nil)
-          unless version && !read_packagemanager(:private)
-            print_error('invalid task "publish"', subject: name, hint: version ? 'private' : nil)
+          if read_package('private')
+            ws = @children.select { |proj| proj.ref?(Node.ref) }
+            if ws.empty?
+              print_error('nothing to publish', subject: name, hint: 'private')
+            elsif confirm_basic('Publish workspace?', ws.map(&:name).join(', '), 'N')
+              ws.each { |proj| proj.publish(flag, sync: sync, otp: otp, tag: tag, access: access, dryrun: dryrun) }
+            end
             return
           end
+          return print_error('version not found', subject: name, hint: dependname) unless version
+
           cmd = session 'npm', 'publish'
           cmd << basic_option('otp', otp) if otp ||= option('otp')
           cmd << basic_option('tag', tag.tr(' ', '-')) if tag ||= option('tag')
@@ -682,134 +805,151 @@ module Squared
           if dryrun
             cmd << '--dry-run'
           else
-            from = :publish
+            from = :'npm:publish'
             log.info cmd.to_s
           end
           if sync
-            run(from: from, sync: sync, interactive: !dryrun && "Publish #{sub_style(npmname, styles: theme[:active])}")
+            run(from: from, sync: sync, interactive: !dryrun && ['Publish', 'N', npmname])
           else
             require 'open3'
             on :first, from
             pwd_set(from: from, dryrun: dryrun) do
-              cmd = session_done cmd
-              Open3.popen2e(cmd) do |_, out|
+              Open3.popen2e(cmd = session_done(cmd)) do |_, out|
                 write_lines(out, banner: format_banner(cmd),
-                                 sub: npmnotice + [pat: /^(.+)(Tarball .+)$/, styles: color(:bright_blue), index: 2])
+                                 sub: npmnotice(opt_style(color(:bright_blue), /^(.+)(Tarball .+)$/, 2)))
               end
             end
             on :last, from
           end
         end
 
-        def package(flag, opts = [], from: nil)
+        def package(flag, opts = [], packages: [], from: nil)
           workspace.rev_clear(name)
           if (yarn = dependtype(:yarn)) > 0
-            cmd = session 'yarn', if flag == :update
+            cmd = session 'yarn', case flag
+                                  when :update
                                     yarn == 1 ? 'upgrade' : 'up'
+                                  when :reinstall
+                                    if yarn == 1
+                                      remove_modules 'yarn' if opts.include?('force')
+                                    elsif opts.delete('force')
+                                      opts << 'check-cache'
+                                    end
+                                    opts << 'no-lockfile' if lockfile(true)
+                                    'install'
                                   else
                                     yarn == 1 && flag == :dedupe ? 'install' : flag
                                   end
             op = OptionPartition.new(opts, if yarn == 1
                                              OPT_YARN.fetch(flag == :dedupe ? :install : flag, []) + OPT_YARN[:common]
                                            else
-                                             OPT_BERRY[flag]
+                                             OPT_BERRY.fetch(flag, [])
                                            end, cmd, project: self)
-            op << '--ignore-engines' if yarn == 1 && !option('ignore-engines', equals: '0')
+            if yarn == 1 && flag != :reinstall
+              op << '--no-lockfile' if nolockfile?('yarn')
+              op << '--ignore-engines' unless option('ignore-engines', equals: '0')
+            end
             op.clear
             append_loglevel
           else
-            if pnpm?
-              cmd = session 'pnpm', flag
-              list = OPT_PNPM[:install_base] + OPT_PNPM.fetch(flag, []) + OPT_PNPM[:common]
-              list.concat(OPT_PNPM[:install_as] + OPT_PNPM[:filter]) unless flag == :dedupe
-              list.concat(OPT_PNPM[:cpu]) unless flag == :update
-              no = OPT_PNPM[:"#{flag}_no"]
-            else
-              cmd = session 'npm', flag
-              list = OPT_NPM[:install_base] + OPT_NPM.fetch(flag, []) + OPT_NPM[:common]
-              list.concat(OPT_NPM[:install_as]) if flag == :install || flag == :update
-              no = OPT_NPM[:install_no]
-            end
-            op = OptionPartition.new(opts, list, cmd, no: no, project: self)
+            args = if pnpm?
+                     case flag
+                     when :install, :update
+                       opts << 'no-lockfile' if nolockfile?('pnpm')
+                     when :reinstall
+                       opts << 'force'
+                       flag = :install
+                     end
+                     no = OPT_PNPM[:no][flag]
+                     [
+                       opts,
+                       [flag, :install_a].yield_self do |out|
+                         out.push(:install_b, :common_filter) unless flag == :dedupe
+                         out << :common_cpu unless flag == :update
+                         pnpmopts(*out)
+                       end,
+                       session('pnpm', flag)
+                     ]
+                   else
+                     case flag
+                     when :install, :update
+                       opts.unshift('package-lock=false', 'save=false') if nolockfile?('npm')
+                     when :reinstall
+                       remove_modules 'npm' if opts.delete('force')
+                       opts.unshift('package-lock=false') if lockfile(true)
+                       flag = :install
+                     end
+                     no = OPT_NPM[:no][:install]
+                     [
+                       opts,
+                       [flag, :install_a].yield_self do |out|
+                         out << :install_b unless flag == :dedupe
+                         npmopts(*out)
+                       end,
+                       session('npm', flag)
+                     ]
+                   end
+            op = OptionPartition.new(*args, no: no, project: self)
             op.each do |opt|
               if opt =~ op.values
                 case $1
                 when 'w', 'workspace'
                   op << ($2.match?(%r{[\\/]}) ? quote_option($1, basepath($2)) : shell_option($1, $2))
                 end
-              elsif opt.include?('=')
+              elsif opt.include?('=') || opt.start_with?('-')
                 op.errors << opt
               else
                 op.found << opt
               end
             end
             op.swap
+              .concat(packages)
             append_platform if flag == :install
             append_nocolor
             append_loglevel
-            if flag == :dedupe || pnpm?
+            if flag == :dedupe
               op.clear
             else
               op.append(quote: true)
             end
+            op.clear(errors: true)
           end
-          op.clear(errors: true)
           run(from: from || :"package:#{flag}")
         end
 
         def bump(flag, val = nil)
-          return unless (cur = version)
-
-          if flag == :version
-            return unless val
-          else
-            seg = semscan(cur, fill: false)
-            case flag
-            when :major
-              if seg[0] != '0' || seg[2].nil?
-                seg[0] = seg[0].succ
-                seg[2] = '0'
-              else
-                seg[2] = seg[2].succ
-              end
-              seg[4] = '0'
-            when :minor
-              if seg[0] == '0'
-                seg[4] &&= seg[4].succ
-              else
-                seg[2] = seg[2].succ
-                seg[4] &&= '0'
-              end
-            when :patch
-              seg[4] &&= seg[4].succ
-            end
-            return if (val = seg.join) == cur
+          if flag != :version
+            val = sembump version, flag
+            return if val == version
+          elsif !val
+            return
           end
-          begin
-            doc = dependfile.read
-            if doc.sub!(/"version"\s*:\s*"#{cur}"/, "\"version\": \"#{val}\"")
-              unless dryrun?
-                dependfile.write(doc)
-                log.info "bump version #{cur} to #{val} (#{flag})"
-                on :first, :bump
-              end
-              if stdin?
-                puts val
-              elsif verbose
-                major = flag == :major
-                emphasize("version: #{val}", title: name, border: borderstyle, sub: [
-                  headerstyle,
-                  { pat: /\A(version:)( )(\S+)(.*)\z/, styles: color(major ? :green : :yellow), index: 3 },
-                  { pat: /\A(version:)(.*)\z/, styles: theme[major ? :major : :active] }
-                ])
-              end
-              on :last, :bump unless dryrun?
-            else
-              raise_error('version not found', hint: dependfile)
+          doc = dependfile.read
+          if doc.sub!(/"version"\s*:\s*"#{version}"/, "\"version\": \"#{val}\"")
+            unless dryrun?
+              log.info "bump version #{version} to #{val.subhint(flag)}"
+              on :first, :bump
+              dependfile.write(doc)
             end
-          rescue StandardError => e
-            on_error e, :bump
+            if stdin?
+              puts val
+            elsif verbose
+              major = flag == :major
+              emphasize("version: #{val}", title: name, border: borderstyle, sub: [
+                headerstyle,
+                opt_style(color(major ? :green : :yellow), /\A(version:)( )(\S+)(.*)\z/, 3),
+                opt_style(theme[major ? :major : :active], /\A(version:)(.*)\z/)
+              ])
+            end
+            unless dryrun?
+              commit(:add, [dependname], pass: true)
+              on :last, :bump
+            end
+          else
+            raise_error 'version not found', hint: dependfile
           end
+        rescue StandardError => e
+          on_error e, :bump
         end
 
         def pack(opts = [])
@@ -820,8 +960,7 @@ module Squared
             op = OptionPartition.new(opts, OPT_BERRY[:pack], cmd, project: self)
             op.append?('out', Pathname.pwd + "#{project}-#{version}.tgz")
           else
-            op = OptionPartition.new(opts, pnpm? ? OPT_PNPM[:pack] : OPT_NPM[:pack] + OPT_NPM[:common], cmd,
-                                     project: self)
+            op = OptionPartition.new(opts, pnpm? ? OPT_PNPM[:pack] : npmopts(:pack), cmd, project: self)
             unless pnpm?
               op.each do |opt|
                 next unless opt =~ op.values
@@ -839,15 +978,53 @@ module Squared
           run(from: :pack)
         end
 
+        def tsc(*args, with: nil, pass: PASS_NODE[:tsc], sync: true, banner: verbose?, from: :tsc, **kwargs)
+          session_apply(with, args: args, kwargs: kwargs, pass: pass) if with
+          p = kwargs[:project]
+          b = kwargs[:build]
+          w = kwargs[:watch]
+          list = OPT_TSC[:base] + OPT_TSC[:compiler]
+          cmd = session 'tsc', if p
+                                 quote_option 'p', basepath(p)
+                               elsif b
+                                 list.concat(OPT_TSC[:build])
+                                 '-b'
+                               end
+          if w
+            list.concat(OPT_TSC[:watch])
+            cmd << '-w'
+          end
+          op = OptionPartition.new(args, list, cmd, project: self, sep: ' ')
+          unless p
+            if b.is_a?(String)
+              op.add_path(b)
+            elsif w.is_a?(String)
+              op.add_path(w)
+            else
+              op.exist?(add: true)
+            end
+          end
+          op.clear
+          cmd = session_done(op.target)
+          print_run(cmd, banner, **kwargs)
+          session 'npx', cmd
+          start = time_epoch if kwargs.fetch(:verbose, verbose? && !stdin?)
+          run(sync: sync, banner: banner, from: from).tap do |ret|
+            next unless success?(ret, banner, start.nil?) && start
+
+            print_status(name, subject: 'tsc', start: start, from: :completed)
+          end
+        end
+
         def compose(target, opts = nil, script: false, args: nil, from: nil, **)
           return unless target
 
           if script
             ret = session dependbin, 'run'
-            raise_error("#{dependbin} run: given #{target}", hint: from) unless append_any(target, build: true)
-            append_any opts
+            raise_error "#{dependbin} run: #{target}", hint: from unless append_any(target, build: true)
+            append_any opts if opts
             append_loglevel
-            append_any(args, delim: true)
+            append_any(args, delim: true) if args
             ret
           else
             case target
@@ -858,7 +1035,7 @@ module Squared
             when Enumerable
               target.to_a.join(' ')
             else
-              raise_error("compose: given #{target}", hint: from)
+              raise_error TypeError, "unknown: #{target}", hint: 'compose'
             end
           end
         end
@@ -868,7 +1045,7 @@ module Squared
         end
 
         def outdated?
-          dependfile.exist? && !task_pass?('outdated')
+          dependfile.exist?
         end
 
         def update?
@@ -880,9 +1057,9 @@ module Squared
         end
 
         def yarn?
-          (@pm[:yarn] ||= if rootpath('yarn.lock', ascend: dependext).exist?
+          (@pm[:yarn] ||= if rootpath('yarn.lock', ascend: dependroot).exist?
                             yarntype
-                          elsif (ver = read_packagemanager || read_install)
+                          elsif (ver = read_package || read_install)
                             if ver =~ /^yarn(?:@(\d)|$)/
                               $1 && $1.to_i > 1 ? yarntype : 1
                             else
@@ -901,9 +1078,9 @@ module Squared
         end
 
         def pnpm?
-          (@pm[:pnpm] ||= if rootpath('pnpm-lock.yaml', ascend: dependext).exist?
+          (@pm[:pnpm] ||= if rootpath('pnpm-lock.yaml', ascend: dependroot).exist?
                             pnpmtype
-                          elsif (ver = read_packagemanager || read_install)
+                          elsif (ver = read_package || read_install)
                             ver.start_with?('pnpm') ? pnpmtype : 0
                           else
                             @pm[:__] == 'pnpm' ? pnpmtype : 0
@@ -912,9 +1089,9 @@ module Squared
 
         def workspaces?
           if pnpm?
-            basepath('pnpm-workspace.yaml').exist?
+            exist?('pnpm-workspace.yaml')
           else
-            read_packagemanager(:workspaces).is_a?(Array)
+            read_package('workspaces').is_a?(Array)
           end
         end
 
@@ -942,76 +1119,76 @@ module Squared
         end
 
         def version
-          @version ||= read_packagemanager(:version)
+          @version ||= read_package('version')
         end
 
         def packagename
-          read_packagemanager :name
+          read_package 'name'
         end
 
         def scripts
-          @scripts ||= read_packagemanager(:scripts).yield_self { |ret| ret.is_a?(Hash) ? ret : {} }
+          @scripts ||= read_package('scripts').yield_self { |ret| ret.is_a?(Hash) ? ret : {} }
         end
 
         private
 
-        def read_packagemanager(key = nil, version: nil, update: false)
-          if (key ? !@pm.key?(key) : @pm[:_].nil?) || update
+        def read_package(key = 'packageManager', update: false)
+          if !@pm.key?(key) || update
             doc = JSON.parse(dependfile.read)
-            if @pm[:_].nil?
-              @pm[:_] = (val = doc['packageManager']) ? val[0, val.index('+') || val.size] : false
-              @pm[:name] = doc['name']
-              @pm[:scripts] = doc['scripts']
-              @pm[:version] = doc['version']
-              @pm[:private] = doc['private']
-              @pm[:workspaces] = doc['workspaces']
+            @pm[key] = case key
+                       when 'packageManager'
+                         if (val = doc['packageManager'])
+                           (n = val.index('+')) ? val[0, n] : val
+                         else
+                           false
+                         end
+                       else
+                         doc[key]
+                       end
+            unless @pm[:_]
+              %w[name scripts version private workspaces].each { |s| @pm[s] = doc[s] }
+              @pm[:_] = true
             end
-            @pm[key] = doc[key.to_s] if key
           end
         rescue StandardError => e
           log.debug e
-          @pm[:_] = false
-          nil
+          @pm[key] = nil
         else
-          if key
-            @pm[key]
-          elsif (ret = @pm[:_]) && (!version || semgte?(ret[(ret.index('@') + 1)..-1], version))
-            ret
-          end
+          @pm[key]
         end
 
         def read_install
-          return unless (ret = env('NODE_INSTALL'))
-
-          if ret.include?(',')
-            catch :found do
-              split_escape(ret).each do |val|
-                case val
-                when /^yarn/
-                  next if yarntype(exist: true) == 0
-                when /^pnpm/
-                  next if pnpmtype(exist: true) == 0
-                when /^npm/
-                  nil
-                else
-                  next
+          env('NODE_INSTALL') do |ret|
+            if ret.include?(',')
+              catch :found do
+                split_escape(ret) do |val|
+                  case val
+                  when /^yarn/
+                    next if yarntype(exist: true) == 0
+                  when /^pnpm/
+                    next if pnpmtype(exist: true) == 0
+                  when /^npm/
+                    nil
+                  else
+                    next
+                  end
+                  ret = val
+                  throw :found
                 end
-                ret = val
-                throw :found
+                return
               end
-              return
             end
+            @pm['packageManager'] ||= ret
+            ret
           end
-          @pm[:_] ||= ret
-          ret
         end
 
         def yarntype(exist: false)
-          if (rc = rootpath('.yarnrc.yml', ascend: dependext)).exist?
+          if (rc = rootpath('.yarnrc.yml', ascend: dependroot)).exist?
             require 'yaml'
             doc = YAML.load_file(rc)
             doc.nodeLinker == 'node-modules' ? 2 : 3
-          elsif exist && !basepath('yarn.lock').exist?
+          elsif exist && !exist?('yarn.lock')
             0
           else
             1
@@ -1025,7 +1202,7 @@ module Squared
 
         def pnpmtype(exist: false)
           require 'yaml'
-          doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: dependext))
+          doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: dependroot))
           @pm['packageManager'] = doc['packageManager']
           case doc['nodeLinker']
           when 'hoisted'
@@ -1037,16 +1214,32 @@ module Squared
           end
         rescue StandardError => e
           if exist
-            %w[pnpm-lock.yaml pnpm-workspace.yaml].any? { |val| basepath(val).exist? } ? 4 : 0
+            %w[pnpm-lock.yaml pnpm-workspace.yaml].any? { |val| exist?(val) } ? 4 : 0
           else
             log.debug e
             4
           end
         end
 
+        def remove_modules(prefix = dependbin)
+          modules = basepath 'node_modules'
+          return false unless modules.directory? && (option('Y', prefix: prefix) || confirm_basic('Remove?', modules))
+
+          modules.rmtree
+        rescue Timeout::Error => e
+          puts
+          print_error(e, hint: modules, pass: true)
+          exit 1
+        rescue StandardError => e
+          print_error(e, pass: true)
+          false
+        else
+          true
+        end
+
         def append_loglevel(target: @session)
           level = env('NODE_LOGLEVEL')
-          silent = verbosetype == 0 || level == 'silent'
+          silent = !verbose || level == 'silent'
           return unless silent || level
 
           if yarn?
@@ -1080,25 +1273,57 @@ module Squared
           %w[cpu os libc].each { |name| option(name) { |val| target << basic_option(name, val) } }
         end
 
-        def dependext
-          'package.json' if parent&.has?('outdated', Node.ref)
+        def dependroot
+          dependname if parent&.has?('outdated', Node.ref)
         end
 
         def npmname
           packagename || project
         end
 
-        def npmnotice
+        def npmnotice(*args)
           [
-            { pat: /^(npm error )(code|\d+)(.+)$/, styles: color(:bright_cyan), index: 2 },
-            { pat: /^(npm )(error)(.*)$/, styles: color(:bright_red), index: 2 },
-            { pat: /^(npm )(notice)(.*)$/, styles: color(:bright_cyan), index: 2 },
-            { pat: /^(npm )(.+)$/, styles: :bold }
-          ]
+            opt_style(color(:bright_cyan), /^(npm error )(code|\d+)(.+)$/, 2),
+            opt_style(color(:bright_red), /^(npm )(error)(.*)$/, 2),
+            opt_style(color(:bright_cyan), /^(npm )(notice)(.*)$/, 2),
+            opt_style(:bold, /^(npm )(.+)$/)
+          ].concat(args)
+        end
+
+        def npmopts(*args)
+          OPT_NPM[:common] + args.flat_map { |name| OPT_NPM.fetch(name, []) }
+        end
+
+        def pnpmopts(*args)
+          OPT_PNPM[:common] + args.flat_map { |name| OPT_PNPM.fetch(name, []) }
+        end
+
+        def lockfile(delete = false)
+          file = basepath(if yarn?
+                            'yarn.lock'
+                          else
+                            pnpm? ? 'pnpm-lock.yaml' : 'package-lock.json'
+                          end)
+          if file.exist?
+            if delete
+              file.delete
+              return
+            end
+            file
+          elsif (file = rootpath(file.basename, ascend: dependroot)).exist?
+            file
+          end
+        rescue StandardError => e
+          log.debug e
+          file
+        end
+
+        def nolockfile?(prefix = dependbin)
+          option('package-lock', 'lockfile', prefix: prefix, equals: '0') || !option('no-lockfile', prefix: prefix).nil?
         end
 
-        def dryrun?(prefix = dependbin, **)
-          super || !option('dry-run', prefix: prefix).nil?
+        def dryrun?(prefix = dependbin)
+          super(target: @session, prefix: prefix)
         end
       end