ocran 1.4.6 → 1.5.1

data/lib/ocran/option.rb

@@ -6,15 +6,21 @@ module Ocran
     load File.expand_path("refine_pathname.rb", __dir__) unless defined? RefinePathname
     using RefinePathname
 
+    # Valid values for --set-requested-execution-level (manifest UAC levels).
+    EXECUTION_LEVELS = %w[asInvoker highestAvailable requireAdministrator].freeze
+
     def initialize
       @options = {
         :add_all_core? => false,
         :add_all_encoding? => true,
+        :application_manifest => nil,
         :argv => [],
         :auto_detect_dlls? => true,
         :bundle_identifier => nil,
         :macosx_bundle => nil,
         :macosx_bundle? => false,
+        :runtime_dlls => [],
+        :static_runtime => nil,
         :chdir_before? => false,
         :chdir_exe_dir? => false,
         :cosmo_cc => nil,
@@ -23,26 +29,44 @@ module Ocran
         :enable_compression? => true,
         :enable_debug_extract? => false,
         :enable_debug_mode? => false,
+        :execution_level => nil,
         :extra_dlls => [],
+        :file_version => nil,
         :force_console? => false,
         :force_windows? => false,
         :gem_options => [],
         :gemfile => nil,
         :icon_filename => nil,
+        :inputs => [],
         :inno_setup_script => nil,
         :load_autoload? => true,
         :output_dir => nil,
         :output_override => nil,
         :output_zip => nil,
+        :product_version => nil,
         :quiet? => false,
+        :resource_strings => {},
+        :roundhouse? => false,
+        :roundhouse_app => nil,
+        :roundhouse_options => [],
+        :roundhouse_output => nil,
         :rubyopt => nil,
         :run_script? => true,
         :script => nil,
         :source_files => [],
+        :spinel? => false,
+        :spinel_options => [],
         :verbose? => false,
+        :version_strings => {},
         :warning? => true,
+        :wasm_options => [],
+        :wasm_output => nil,
+        :wasm_ruby => nil,
+        :wasm_runtime => nil,
+        :wasm_zip? => false,
         :wrapper_exe? => true,
       }
+      @warnings = []
     end
 
     def usage
@@ -69,7 +93,7 @@ Gem content detection modes:
 --gem-guess=[gem1,...]   Include loaded scripts & best guess (DEFAULT)
 --gem-all[=gem1,..]      Include all scripts & files
 --gem-full[=gem1,..]     Include EVERYTHING
---gem-spec[=gem1,..]     Include files in gemspec (Does not work with Rubygems 1.7+)
+--gem-spec[=gem1,..]     Include the files listed in the gemspec
 
   minimal: loaded scripts
   guess: loaded scripts and other files
@@ -86,7 +110,8 @@ Gem content detection modes:
 
 Auto-detection options:
 
---no-dep-run       Don't run script.rb to check for dependencies.
+--no-dep-run       Don't run script.rb to check for dependencies (usually
+                   needs --add-all-core, and --gem-full with --gemfile).
 --no-autoload      Don't load/include script.rb's autoloads.
 --no-autodll       Disable detection of runtime DLL dependencies.
 
@@ -116,8 +141,38 @@ Executable options:
 --debug            Executable will be verbose.
 --debug-extract    Executable will unpack to local dir and not delete after.
 
+PE resource options (Windows, rcedit-compatible):
+
+--set-version-string <key> <value>  Add a StringFileInfo entry (e.g. CompanyName).
+                                     Alias: --version-string
+--set-file-version <x.y.z.w>         Set the file version. Alias: --file-version
+--set-product-version <x.y.z.w>      Set the product version. Alias: --product-version
+--set-resource-string <id> <value>   Set an RT_STRING table entry by numeric id.
+                                     Alias: --resource-string
+--set-requested-execution-level <level>  Set the manifest UAC level (asInvoker,
+                                     highestAvailable, requireAdministrator).
+                                     Alias: --uac-level
+--application-manifest <file>        Embed the given file as the application manifest.
+                                     Alias: --manifest
+
 Experimental options:
 
+--static-runtime <runtime-dir>  Build a single executable that runs the
+                   application without extracting anything: a statically
+                   linked Ruby (the static runtime in <runtime-dir>, built
+                   with the scripts in runtime/) with the application as a
+                   ZIP archive. The runtime decides the target: Windows or
+                   Linux (archive appended, readable with unzip or 7-Zip)
+                   or macOS (archive linked in as section __OCRAN,__zip;
+                   packaging needs a Mac). The runtime's own standard
+                   library and bundled gems are packed; C extensions must
+                   be linked into the runtime. The build host's Ruby must
+                   have the runtime's API version (e.g. 4.0.0).
+--runtime-dll <lib,...>  With --static-runtime: link these C libraries of the
+                   runtime's SDK as DLLs shipped next to the executable
+                   instead of into it (e.g. iconv,sybdb - the LGPL ones;
+                   see runtime/LICENSES.md). Their DLL dependencies come
+                   along.
 --cosmo-ruby <ruby.com>  Package the given cosmopolitan-built Ruby (an APE,
                    e.g. ruby.com) as the interpreter instead of the host
                    Ruby: the result is a single <scriptname>.com that runs
@@ -144,6 +199,50 @@ Experimental options:
                    packages the host Ruby behind an APE stub. Console-only;
                    output defaults to <scriptname>.com.
                    (Alias: --cosmo-toolchain)
+
+Native compilation (experimental):
+
+--spinel           Compile script.rb ahead of time with Spinel
+                   (https://github.com/matz/spinel) into a native executable
+                   that needs no Ruby, instead of packaging the interpreter.
+                   Spinel compiles a subset of Ruby: when the program is
+                   outside it, OCRAN reports what in your code and in which
+                   gems stands in the way. The script is not run at build
+                   time. Requires the spinel command (SPINEL, PATH, or
+                   ~/.local/bin); OCRAN explains how to install it.
+--spinel-opt <arg> Pass <arg> to the spinel compiler (repeatable), e.g.
+                   --spinel-opt --int-overflow=promote
+--roundhouse       Compile a Rails application with Roundhouse
+                   (https://github.com/rubys/roundhouse) and Spinel into a
+                   native server binary. Give the application directory
+                   instead of a script (default: the current directory).
+                   The output is a directory (default <app>-spinel, or
+                   --output/--output-dir) with the binary and the files it
+                   serves. When the app is not covered yet, OCRAN shows
+                   Roundhouse's analysis, including which gems it does not
+                   support. Requires roundhouse, spinel and spin.
+--roundhouse-opt <arg>  Pass <arg> to roundhouse (repeatable), e.g.
+                   --roundhouse-opt --survey
+
+WebAssembly (experimental):
+
+--wasm[=ruby|picoruby]  Export the application as a web page that runs it
+                   in the browser on WebAssembly: a folder (default
+                   <scriptname>-wasm, or --output-dir) or a zip archive
+                   (--output-zip, or an --output name ending in .zip) with
+                   index.html, the runtime and the application.
+                   ruby: ruby.wasm, CRuby with its standard library; needs
+                   rbwasm (gem install ruby_wasm). Gems must be listed in
+                   the application's Gemfile.
+                   picoruby: PicoRuby, a 2 MB mruby-based runtime with its
+                   own small library and no gems; needs nothing installed.
+                   OCRAN reports what in the program and its gems may not
+                   work there. The script is not run at build time.
+--picoruby         Same as --wasm=picoruby.
+--wasm-ruby <x.y>  The CRuby version for --wasm (4.0, 3.4, 3.3 or 3.2;
+                   default: this Ruby's, when ruby.wasm has it).
+--wasm-opt <arg>   Pass <arg> to `rbwasm build` (repeatable), used when the
+                   application has gems.
 EOF
     end
 
@@ -163,6 +262,32 @@ EOF
       load File.expand_path("cosmo_toolchain.rb", __dir__) unless defined? CosmoToolchain
     end
 
+    # The --gem-<group> options GemSpecQueryable.gem_inclusion_set knows,
+    # and the file sets among them that --no-gem-<set> can take away.
+    GEM_GROUPS = %i[minimal guess all full spec scripts files extras].freeze
+    GEM_FILE_SETS = %i[scripts files extras].freeze
+
+    # Warnings about the command line, for the caller to print once output
+    # is set up.
+    attr_reader :warnings
+
+    # The value of an option that takes a path or name: the next argument,
+    # which must be there and must not be empty.
+    def required_argument(argv, option)
+      value = argv.shift
+      raise "#{option} requires an argument" if value.nil? || value.empty?
+
+      value
+    end
+    private :required_argument
+
+    # Whether a --gem-* option makes every gem be packed with all of its
+    # scripts, which is what a build without the dependency run needs.
+    def whole_gems?
+      gem_options.any? { |negate, group, list| list.nil? && !negate && %i[all full spec scripts].include?(group) }
+    end
+    private :whole_gems?
+
     def parse(argv)
       while (arg = argv.shift)
         case arg
@@ -173,23 +298,19 @@ EOF
         when "--add-all-core"
           @options[:add_all_core?] = true
         when "--output"
-          path = argv.shift
-          @options[:output_override] = Pathname.new(path).expand_path if path
+          @options[:output_override] = Pathname.new(required_argument(argv, arg)).expand_path
         when "--output-dir"
-          path = argv.shift
-          @options[:output_dir] = Pathname.new(path).expand_path if path
+          @options[:output_dir] = Pathname.new(required_argument(argv, arg)).expand_path
         when "--output-zip"
-          path = argv.shift
-          @options[:output_zip] = Pathname.new(path).expand_path if path
+          @options[:output_zip] = Pathname.new(required_argument(argv, arg)).expand_path
         when "--no-wrapper-exe"
           @options[:wrapper_exe?] = false
         when "--macosx-bundle"
           @options[:macosx_bundle?] = true
         when "--bundle-id"
-          @options[:bundle_identifier] = argv.shift
+          @options[:bundle_identifier] = required_argument(argv, arg)
         when "--dll"
-          path = argv.shift
-          @options[:extra_dlls] << path if path
+          @options[:extra_dlls] << required_argument(argv, arg)
         when "--quiet"
           @options[:quiet?] = true
         when "--verbose"
@@ -205,26 +326,81 @@ EOF
         when "--chdir-exe-dir"
           @options[:chdir_exe_dir?] = true
         when "--icon"
-          path = argv.shift
-          raise "Icon file #{path} not found" unless path && File.exist?(path)
+          path = required_argument(argv, arg)
+          raise "Icon file #{path} not found" unless File.exist?(path)
           @options[:icon_filename] = Pathname.new(path).expand_path
+        when "--set-version-string", "--version-string"
+          key = argv.shift
+          value = argv.shift
+          raise "#{arg} requires a key and a value" unless key && value
+          @options[:version_strings][key] = value
+        when "--set-file-version", "--file-version"
+          value = argv.shift
+          raise "#{arg} requires a version string" unless value
+          @options[:file_version] = value
+        when "--set-product-version", "--product-version"
+          value = argv.shift
+          raise "#{arg} requires a version string" unless value
+          @options[:product_version] = value
+        when "--set-resource-string", "--resource-string"
+          id = argv.shift
+          value = argv.shift
+          raise "#{arg} requires an id and a value" unless id && value
+          @options[:resource_strings][id.to_i] = value
+        when "--set-requested-execution-level", "--uac-level"
+          level = argv.shift
+          unless EXECUTION_LEVELS.include?(level)
+            raise "#{arg} must be one of: #{EXECUTION_LEVELS.join(", ")}"
+          end
+          @options[:execution_level] = level
+        when "--application-manifest", "--manifest"
+          path = argv.shift
+          raise "Manifest file #{path} not found" unless path && File.exist?(path)
+          @options[:application_manifest] = Pathname.new(path).expand_path
         when "--rubyopt"
-          @options[:rubyopt] = argv.shift
+          # An empty value is meaningful: run with no RUBYOPT at all.
+          @options[:rubyopt] = argv.shift or raise "#{arg} requires an argument"
         when "--cosmo", "--cosmo-toolchain"
           # Kept unresolved until validation: resolving here would report
           # "cosmocc ... is not executable" on a Windows build host, ahead of
           # the clearer "not supported when building on Windows" check.
-          @options[:cosmo_cc] = argv.shift
+          @options[:cosmo_cc] = required_argument(argv, arg)
+        when "--spinel"
+          @options[:spinel?] = true
+        when "--spinel-opt"
+          @options[:spinel_options] << required_argument(argv, arg)
+        when "--roundhouse"
+          @options[:roundhouse?] = true
+        when /\A--wasm(?:=(.*))?\z/
+          runtime = $1.nil? || $1.empty? ? "ruby" : $1
+          @options[:wasm_runtime] =
+            case runtime
+            when "ruby", "ruby.wasm", "cruby" then :ruby
+            when "picoruby" then :picoruby
+            else raise "Unknown --wasm runtime #{runtime.inspect} (use --wasm=ruby or --wasm=picoruby)"
+            end
+        when "--picoruby"
+          @options[:wasm_runtime] = :picoruby
+        when "--wasm-ruby"
+          @options[:wasm_ruby] = required_argument(argv, arg)
+        when "--wasm-opt"
+          @options[:wasm_options] << required_argument(argv, arg)
+        when "--roundhouse-opt"
+          @options[:roundhouse_options] << required_argument(argv, arg)
+        when "--static-runtime"
+          @options[:static_runtime] = Pathname.new(required_argument(argv, arg)).expand_path
+        when "--runtime-dll"
+          @options[:runtime_dlls] |= required_argument(argv, arg).split(",").map(&:strip).reject(&:empty?)
         when "--cosmo-ruby"
           load_cosmo_toolchain
           @options[:cosmo_ruby] = CosmoToolchain.resolve_ruby(argv.shift)
         when "--gemfile"
-          path = argv.shift
-          raise "Gemfile #{path} not found" unless path && File.exist?(path)
+          path = required_argument(argv, arg)
+          raise "Gemfile #{path} not found" unless File.exist?(path)
           @options[:gemfile] = Pathname.new(path).expand_path
         when "--innosetup"
-          path = argv.shift
-          raise "Inno Script #{path} not found" unless path && File.exist?(path)
+          path = required_argument(argv, arg)
+          raise "Inno Script #{path} not found" unless File.exist?(path)
           @options[:inno_setup_script] = Pathname.new(path).expand_path
         when "--no-autodll"
           @options[:auto_detect_dlls?] = false
@@ -246,25 +422,44 @@ EOF
           @options[:add_all_encoding?] = !$1
         when /\A--(no-)?gem-(\w+)(?:=(.*))?$/
           negate, group, list = $1, $2, $3
-          @options[:gem_options] << [negate, group.to_sym, list&.split(",")] if group
-        when "--help", "-h", /\A--./
+          group = group.to_sym
+          if negate ? !GEM_FILE_SETS.include?(group) : !GEM_GROUPS.include?(group)
+            raise "Invalid gem content detection option #{arg}: use " \
+                  "#{GEM_GROUPS.map { |g| "--gem-#{g}" }.join(", ")} or " \
+                  "#{GEM_FILE_SETS.map { |g| "--no-gem-#{g}" }.join(", ")}"
+          end
+          @options[:gem_options] << [negate, group, list&.split(",")]
+        when "--help", "-h"
           puts usage
           raise SystemExit
+        when /\A--./
+          raise "Unknown option #{arg} (see ocran --help)"
         else
-          expanded = Dir.glob(arg)
-          if expanded.empty?
-            raise "#{arg} not found!" unless File.exist?(arg)
-            expanded = [arg]
-          end
+          @options[:inputs] << arg
+        end
+      end
 
-          expanded.each do |f|
-            if File.directory?(f)
-              raise "#{f} is empty!" if Dir.empty?(f)
-              # If a directory is passed, we want all files under that directory
-              @options[:source_files] += Pathname.new(f).find.reject(&:directory?).map(&:expand_path)
-            else
-              @options[:source_files] << Pathname.new(f).expand_path
-            end
+      if roundhouse?
+        # A Rails application directory rather than a script: none of the
+        # packaging below applies, and the application is not loaded.
+        parse_roundhouse
+        return
+      end
+
+      @options[:inputs].each do |arg|
+        expanded = Dir.glob(arg)
+        if expanded.empty?
+          raise "#{arg} not found!" unless File.exist?(arg)
+          expanded = [arg]
+        end
+
+        expanded.each do |f|
+          if File.directory?(f)
+            raise "#{f} is empty!" if Dir.empty?(f)
+            # If a directory is passed, we want all files under that directory
+            @options[:source_files] += Pathname.new(f).find.reject(&:directory?).map(&:expand_path)
+          else
+            @options[:source_files] << Pathname.new(f).expand_path
           end
         end
       end
@@ -273,6 +468,17 @@ EOF
 
       @options[:script] = source_files.first
 
+      if wasm_runtime
+        parse_wasm
+      end
+
+      if spinel?
+        reject_with_native_compilation("--spinel", output_dir: "--output-dir")
+        # Spinel compiles the source; it never needs the program to run, and
+        # running it would only pull OCRAN's dependency detection in.
+        @options[:run_script?] = false
+      end
+
       @options[:force_autoload?] = run_script? && load_autoload?
 
       @options[:output_executable] =
@@ -281,7 +487,8 @@ EOF
           # without .exe - `--output myapp`, as a build script shared with
           # Linux and macOS writes it - gets one there. .exe and .com names
           # are used as given.
-          if Gem.win_platform? && !output_override.extname?(".exe") && !output_override.extname?(".com")
+          windows_target = static_runtime ? static_runtime_os == "windows" : Gem.win_platform?
+          if windows_target && !output_override.extname?(".exe") && !output_override.extname?(".com")
             Pathname("#{output_override}.exe")
           else
             output_override
@@ -294,6 +501,8 @@ EOF
           # APE binaries built with cosmocc conventionally use .com.
           ext = if cosmo?
                   ".com"
+                elsif static_runtime
+                  static_runtime_os == "windows" ? ".exe" : ""
                 elsif Gem.win_platform?
                   ".exe"
                 else
@@ -311,6 +520,28 @@ EOF
         raise "--chdir-first and --chdir-exe-dir cannot be used together"
       end
 
+      if force_windows? && force_console?
+        raise "--windows and --console cannot be used together"
+      end
+
+      if inno_setup_script && (output_dir || output_zip)
+        raise "--innosetup cannot be combined with --output-dir or --output-zip"
+      end
+
+      unless run_script?
+        # Without the dependency run nothing the script loads is detected,
+        # so the libraries it needs must be named some other way.
+        unless add_all_core?
+          @warnings << "--no-dep-run without --add-all-core: the script is not run, so none of the " \
+                       "standard library it requires is detected or packed"
+        end
+        if gemfile && !whole_gems?
+          @warnings << "--no-dep-run with --gemfile but without --gem-all or --gem-full: the script " \
+                       "is not run, so no gem file it loads is detected, and the gems are packed " \
+                       "without their scripts"
+        end
+      end
+
       @options[:use_inno_setup?] = !!inno_setup_script
 
       @options[:verbose?] &&= !quiet?
@@ -373,12 +604,112 @@ EOF
       if macosx_bundle && (output_dir || output_zip || inno_setup_script)
         raise "--macosx-bundle cannot be combined with --output-dir, --output-zip, or --innosetup"
       end
+
+      if static_runtime
+        reject_with_static_runtime
+        raise "#{static_runtime} is not a directory" unless static_runtime.directory?
+      end
+      raise "--runtime-dll needs --static-runtime" if runtime_dlls.any? && !static_runtime
+    end
+
+    # --static-runtime produces one executable from a prebuilt runtime, so neither
+    # the other output formats nor what only the C stub implements apply.
+    def reject_with_static_runtime
+      conflicts = {
+        "--output-dir" => output_dir,
+        "--output-zip" => output_zip,
+        "--innosetup" => inno_setup_script,
+        "--macosx-bundle" => @options[:macosx_bundle?],
+        "--cosmo/--cosmo-ruby" => cosmo?,
+        "--spinel/--roundhouse" => spinel? || roundhouse?,
+        "--wasm" => wasm_runtime,
+        "--debug-extract" => enable_debug_extract?,
+      }
+      conflicts.each do |name, given|
+        raise "#{name} cannot be used with --static-runtime" if given
+      end
+    end
+    private :reject_with_static_runtime
+
+    # Validates --wasm and works out where the site goes: a zip archive for
+    # --output-zip or an --output name ending in .zip, a folder otherwise.
+    def parse_wasm
+      mode = wasm_runtime == :picoruby ? "--wasm=picoruby" : "--wasm"
+      reject_with_native_compilation(mode, output_zip: false)
+      raise "#{mode} cannot be used with --spinel or --roundhouse" if spinel? || roundhouse?
+      raise "--output-dir and --output-zip cannot be used together" if output_dir && output_zip
+
+      suffix = wasm_runtime == :picoruby ? "-picoruby" : "-wasm"
+      if output_zip || output_override&.extname?(".zip")
+        @options[:wasm_zip?] = true
+        @options[:wasm_output] = output_zip || output_override
+      else
+        @options[:wasm_output] = output_dir || output_override ||
+                                 Pathname("#{script.basename(".*")}#{suffix}").expand_path
+      end
+      # Nothing runs at build time: the browser is where the program runs.
+      @options[:run_script?] = false
+    end
+    private :parse_wasm
+
+    # Validates --roundhouse and works out the application and the output
+    # directory.
+    def parse_roundhouse
+      raise "--static-runtime cannot be used with --roundhouse" if static_runtime
+      raise "--roundhouse takes one Rails application directory" if @options[:inputs].size > 1
+      reject_with_native_compilation("--roundhouse")
+      raise "--spinel and --roundhouse cannot be used together (--roundhouse compiles with Spinel already)" if spinel?
+
+      input = Pathname(@options[:inputs].first || Dir.pwd).expand_path
+      raise "#{input} not found!" unless input.exist?
+
+      app = rails_root(input.directory? ? input : input.dirname)
+      unless app
+        raise "#{input} is not a Rails application (no config/application.rb in it or above it); " \
+              "--roundhouse compiles a Rails app - use --spinel for a plain script"
+      end
+
+      output = output_dir || output_override || Pathname("#{app.basename}-spinel").expand_path
+      raise "The output directory #{output} would overwrite the application itself" if output == app
+
+      @options[:roundhouse_app] = app
+      @options[:roundhouse_output] = output
+      @options[:run_script?] = false
+      @options[:force_autoload?] = false
+      @options[:verbose?] &&= !quiet?
+    end
+    private :parse_roundhouse
+
+    # The Rails application root at or above the given directory.
+    def rails_root(dir)
+      dir.ascend.find { |d| (d + "config" + "application.rb").file? }
+    end
+    private :rails_root
+
+    # Native compilation produces a program, not a package of one, so the
+    # options that shape a package do not apply to it.
+    def reject_with_native_compilation(mode, output_dir: nil, output_zip: true)
+      conflicts = {
+        "--innosetup" => inno_setup_script,
+        "--macosx-bundle" => @options[:macosx_bundle?],
+        "--cosmo/--cosmo-ruby" => cosmo?,
+        "--windows" => force_windows?,
+        "--icon" => icon_filename,
+      }
+      conflicts[output_dir] = self.output_dir if output_dir
+      conflicts["--output-zip"] = self.output_zip if output_zip
+      conflicts.each do |name, given|
+        raise "#{name} cannot be used with #{mode}" if given
+      end
     end
+    private :reject_with_native_compilation
 
     def add_all_core? = @options[__method__]
 
     def add_all_encoding? = @options[__method__]
 
+    def application_manifest = @options[__method__]
+
     def argv = @options[__method__]
 
     def bundle_identifier = @options[__method__]
@@ -394,6 +725,23 @@ EOF
 
     def cosmo_ruby = @options[__method__]
 
+    # Directory of the static runtime given with --static-runtime, or nil.
+    def static_runtime = @options[__method__]
+
+    def static_runtime? = !!static_runtime
+
+    # The operating system the --static-runtime runtime is for, from its
+    # runtime.json ("windows" when that cannot be read yet).
+    def static_runtime_os
+      require "json"
+      JSON.parse(File.read(File.join(static_runtime, "runtime.json"))).fetch("os", "windows")
+    rescue SystemCallError, JSON::ParserError
+      "windows"
+    end
+
+    # C libraries --runtime-dll ships as DLLs next to the executable.
+    def runtime_dlls = @options[__method__]
+
     # True when the application is packaged by injecting it into the ZIP
     # store of the cosmopolitan Ruby itself: no cosmocc, no launcher stub,
     # and no extraction to a temporary directory at run time.
@@ -418,8 +766,12 @@ EOF
 
     def enable_debug_mode? = @options[__method__]
 
+    def execution_level = @options[__method__]
+
     def extra_dlls = @options[__method__]
 
+    def file_version = @options[__method__]
+
     def force_autoload? = @options[__method__]
 
     def force_console? = @options[__method__]
@@ -444,12 +796,42 @@ EOF
 
     def output_zip = @options[__method__]
 
+    def product_version = @options[__method__]
+
     def quiet? = @options[__method__]
 
+    def resource_strings = @options[__method__]
+
     def wrapper_exe? = @options[__method__]
 
     def rubyopt = @options[__method__]
 
+    def roundhouse? = @options[__method__]
+
+    # The root directory of the Rails application --roundhouse compiles.
+    def roundhouse_app = @options[__method__]
+
+    def roundhouse_options = @options[__method__]
+
+    # The directory --roundhouse writes the binary and its files to.
+    def roundhouse_output = @options[__method__]
+
+    def spinel? = @options[__method__]
+
+    def spinel_options = @options[__method__]
+
+    # :ruby (ruby.wasm) or :picoruby with --wasm, else nil.
+    def wasm_runtime = @options[__method__]
+
+    def wasm_options = @options[__method__]
+
+    def wasm_ruby = @options[__method__]
+
+    # The folder or zip archive --wasm writes.
+    def wasm_output = @options[__method__]
+
+    def wasm_zip? = @options[__method__]
+
     def run_script? = @options[__method__]
 
     def script = @options[__method__]
@@ -490,11 +872,59 @@ EOF
 
     def verbose? = @options[__method__]
 
+    def version_strings = @options[__method__]
+
     def warning? = @options[__method__]
 
     def windowed?
+      if static_runtime?
+        # The runtime decides, not the build host. For a runtime that is
+        # not for Windows only an explicit --windows counts, so that the
+        # builder can reject it; a .rbw script is just a script there.
+        return static_runtime_os == "windows" ? @options[:windowed?] : force_windows?
+      end
       return false unless Gem.win_platform?
       @options[:windowed?]
     end
+
+    # Where the compiled launcher stubs live (StubBuilder::STUB_PATH and
+    # STUBW_PATH). A released gem ships them; a git checkout, such as
+    # Bundler's `gem "ocran", git: ...`, has only their sources in src/.
+    STUB_DIR = File.expand_path("../../share/ocran", __dir__)
+
+    # The prebuilt stub the build will copy, or nil when it copies none:
+    # native compilation, --wasm, --static-runtime and --cosmo-ruby's ZIP
+    # mode use no stub, --cosmo compiles its own, and installer, directory
+    # and zip output only need one for the wrapper executable.
+    def prebuilt_stub
+      return nil if spinel? || roundhouse? || wasm_runtime || static_runtime? || cosmo_zip? || cosmo_cc
+      return nil if (inno_setup_script || output_dir || output_zip) && !wrapper_exe?
+
+      name = if !Gem.win_platform? then "stub"
+             elsif windowed? && !macosx_bundle then "stubw.exe"
+             else "stub.exe"
+             end
+      File.join(STUB_DIR, name)
+    end
+
+    # Fails when the build needs a stub that was never compiled. Checked
+    # before the dependency run, which can take minutes, since the build
+    # would otherwise end in a bare ENOENT for the stub after it.
+    def check_prebuilt_stub(path = prebuilt_stub)
+      return if path.nil? || File.exist?(path)
+
+      root = File.dirname(STUB_DIR, 2)
+      build = if RUBY_PLATFORM.include?("mswin")
+                "`nmake -f Makefile.mswin install` in #{File.join(root, "src")} from a Visual Studio developer prompt"
+              elsif Gem.win_platform?
+                "`ridk exec make -C src install` in #{root}"
+              else
+                "`make -C src install` in #{root}"
+              end
+      message = "The launcher stub #{path} has not been built (OCRAN from a git checkout " \
+                "ships only its sources): run #{build}"
+      message += ", or pass --no-wrapper-exe to skip the wrapper executable" if inno_setup_script || output_dir || output_zip
+      raise message
+    end
   end
 end