ocran 1.4.5 → 1.5.0

data/lib/ocran/dir_builder.rb

@@ -2,13 +2,14 @@
 require "pathname"
 require "fileutils"
 require_relative "build_constants"
+require_relative "windows_command_escaping"
 
 module Ocran
   # Builder that outputs all files to a plain directory instead of a self-extracting
   # executable.  A launch script (`.sh` on POSIX, `.bat` on Windows) is written at
   # the root of the directory so the packaged app can be started directly.
   class DirBuilder
-    include BuildConstants
+    include BuildConstants, WindowsCommandEscaping
 
     WINDOWS = Gem.win_platform?
 
@@ -17,8 +18,20 @@ module Ocran
     # by Direction to build the optional wrapper executable.
     attr_reader :env, :exec_args
 
-    def initialize(path)
+    # +script_name+ names the launch script (without extension); it defaults
+    # to the name of the script that is executed. Direction passes the
+    # user's script, because what is executed can be a generated launcher
+    # (see Direction#generate_rubyopt_launcher).
+    #
+    # +chdir_before+ and +chdir_exe_dir+ mirror the stub flags of the same
+    # names (--chdir-first, --chdir-exe-dir): the launch script changes into
+    # the directory of the packed script, or into its own directory, which
+    # is where the output directory keeps the application.
+    def initialize(path, script_name: nil, chdir_before: false, chdir_exe_dir: false)
       @path = Pathname(path)
+      @script_name = script_name
+      @chdir_before = chdir_before
+      @chdir_exe_dir = chdir_exe_dir
       @path.mkpath
       @env = {}
       @exec_args = nil
@@ -55,17 +68,33 @@ module Ocran
       @exec_args = [image.to_s, script.to_s, argv.map(&:to_s)]
     end
 
-    # Create a zip archive from a source directory.
+    # PowerShell command for create_zip on Windows. The paths come in through
+    # the environment rather than being spliced into the command, so no
+    # character in them (a quote in a user name, brackets) can change its
+    # meaning; -LiteralPath keeps wildcards in the source path literal.
+    POWERSHELL_ZIP_COMMAND =
+      "$ErrorActionPreference = 'Stop'; " \
+      "Get-ChildItem -LiteralPath $env:OCRAN_ZIP_SOURCE -Force | " \
+      "Compress-Archive -DestinationPath $env:OCRAN_ZIP_DESTINATION"
+
+    # Create a zip archive from a source directory, replacing any archive
+    # already at +zip_path+.
     # Uses the `zip` command on POSIX and PowerShell on Windows.
     def self.create_zip(zip_path, source_dir)
       zip_path = File.expand_path(zip_path.to_s)
+      # Both tools add to an existing archive rather than replace it (zip
+      # keeps entries the new tree no longer has; Compress-Archive refuses
+      # without -Force), so start from nothing.
+      FileUtils.rm_f(zip_path)
       if Gem.win_platform?
-        system("powershell", "-NoProfile", "-Command",
-               "Compress-Archive -Path '#{source_dir}\\*' -DestinationPath '#{zip_path}'",
+        env = { "OCRAN_ZIP_SOURCE" => source_dir.to_s, "OCRAN_ZIP_DESTINATION" => zip_path }
+        system(env, "powershell", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_ZIP_COMMAND,
                exception: true)
       else
+        # -y stores symlinks (the libruby.so aliases) as links; without it
+        # zip follows them and stores the library once per alias.
         Dir.chdir(source_dir) do
-          system("zip", "-r", zip_path, ".", exception: true)
+          system("zip", "-q", "-r", "-y", zip_path, ".", exception: true)
         end
       end
     end
@@ -84,13 +113,41 @@ module Ocran
       write_launch_script
     end
 
-    # Replace the EXTRACT_ROOT placeholder ("|") in a value string with
-    # the runtime directory variable.
-    def replace_root(value, root_var)
-      value.gsub("#{EXTRACT_ROOT}/", "#{root_var}/")
+    # Anchors a relative packed path at the extraction root placeholder;
+    # absolute paths are kept as they are.
+    def root_path(path)
+      return path if path.start_with?("#{EXTRACT_ROOT}/") || File.absolute_path?(path)
+      "#{EXTRACT_ROOT}/#{path}"
+    end
+
+    # Quotes +value+ as one POSIX shell word. The extraction root placeholder
+    # becomes "$SCRIPT_DIR"; everything else is single-quoted, so the shell
+    # expands nothing in it.
+    def shell_word(value)
+      word = value.split("#{EXTRACT_ROOT}/", -1).map { |part|
+        part.empty? ? "" : "'#{part.gsub("'", %q('"'"'))}'"
+      }.join('"$SCRIPT_DIR"/')
+      word.empty? ? "''" : word
+    end
+
+    # The batch script's reference to its own directory, which ends in a
+    # backslash; see WindowsCommandEscaping#batch_value.
+    BATCH_SCRIPT_DIR = "%SCRIPT_DIR%"
+
+    # The directory the launch script changes into before it starts the
+    # application, as a packed path (see root_path), or nil to stay put.
+    def chdir_target
+      if @chdir_exe_dir
+        EXTRACT_ROOT.to_s
+      elsif @chdir_before && @exec_args
+        dir = File.dirname(@exec_args[1])
+        dir == "." ? EXTRACT_ROOT.to_s : root_path(dir)
+      end
     end
 
     def script_basename
+      return @script_name.to_s if @script_name
+
       @exec_args ? Pathname(@exec_args[1]).basename.sub_ext("").to_s : "run"
     end
 
@@ -107,24 +164,18 @@ module Ocran
       ]
 
       @env.each do |name, value|
-        replaced = replace_root(value, "$SCRIPT_DIR")
-        lines << "export #{name}=\"#{replaced}\""
+        lines << "export #{name}=#{shell_word(value)}"
+      end
+
+      if (dir = chdir_target)
+        target = dir == EXTRACT_ROOT.to_s ? '"$SCRIPT_DIR"' : shell_word(dir)
+        lines << "cd #{target} || exit 1"
       end
 
       if @exec_args
         image, script, argv = @exec_args
-        image_r = replace_root(image, "$SCRIPT_DIR")
-        script_r = replace_root(script, "$SCRIPT_DIR")
-
-        # Prepend SCRIPT_DIR to relative paths
-        image_r = "$SCRIPT_DIR/#{image_r}" unless image_r.start_with?("/", "$SCRIPT_DIR")
-        script_r = "$SCRIPT_DIR/#{script_r}" unless script_r.start_with?("/", "$SCRIPT_DIR")
-
-        args = argv.map { |a| "\"#{replace_root(a, "$SCRIPT_DIR")}\"" }.join(" ")
-        exec_line = "exec \"#{image_r}\" \"#{script_r}\""
-        exec_line += " #{args}" unless args.empty?
-        exec_line += ' "$@"'
-        lines << exec_line
+        words = [root_path(image), root_path(script), *argv].map { |a| shell_word(a) }
+        lines << "exec #{words.join(" ")} \"$@\""
       end
 
       File.write(script_path, lines.join("\n") + "\n")
@@ -134,29 +185,28 @@ module Ocran
     def write_batch_script
       script_path = @path / "#{script_basename}.bat"
 
+      # setlocal keeps the variables and the working directory set here from
+      # outliving the script in the cmd.exe session that ran it.
       lines = [
         "@echo off",
-        "set SCRIPT_DIR=%~dp0",
+        "setlocal",
+        'set "SCRIPT_DIR=%~dp0"',
       ]
 
       @env.each do |name, value|
-        replaced = replace_root(value, "%SCRIPT_DIR%").tr("/", "\\")
-        lines << "set #{name}=#{replaced}"
+        lines << "set \"#{name}=#{batch_value(value, BATCH_SCRIPT_DIR).tr("/", "\\")}\""
+      end
+
+      if (dir = chdir_target)
+        target = dir == EXTRACT_ROOT.to_s ? BATCH_SCRIPT_DIR : batch_value(dir, BATCH_SCRIPT_DIR).tr("/", "\\")
+        lines << "cd /d #{quote_and_escape(target)} || exit /b 1"
       end
 
       if @exec_args
         image, script, argv = @exec_args
-        image_r = replace_root(image, "%SCRIPT_DIR%").tr("/", "\\")
-        script_r = replace_root(script, "%SCRIPT_DIR%").tr("/", "\\")
-
-        image_r = "%SCRIPT_DIR%#{image_r}" unless image_r.include?("%SCRIPT_DIR%") || File.absolute_path?(image_r)
-        script_r = "%SCRIPT_DIR%#{script_r}" unless script_r.include?("%SCRIPT_DIR%") || File.absolute_path?(script_r)
-
-        args = argv.map { |a| replace_root(a, "%SCRIPT_DIR%") }.join(" ")
-        exec_line = "\"#{image_r}\" \"#{script_r}\""
-        exec_line += " #{args}" unless args.empty?
-        exec_line += " %*"
-        lines << exec_line
+        words = [root_path(image), root_path(script)].map { |p| batch_value(p, BATCH_SCRIPT_DIR).tr("/", "\\") }
+        words += argv.map { |a| batch_value(a, BATCH_SCRIPT_DIR) }
+        lines << "#{words.map { |w| quote_and_escape(w) }.join(" ")} %*"
       end
 
       File.write(script_path, lines.join("\r\n") + "\r\n")

data/lib/ocran/direction.rb

@@ -16,7 +16,9 @@ module Ocran
     # - /ruby/3.0.0/
     # - /ruby/site_ruby/3.0.0/
     # - /ruby/vendor_ruby/3.0.0/
-    RUBY_LIBRARY_PATH_REGEX = %r{/(ruby/(?:site_ruby/|vendor_ruby/)?\d+\.\d+\.\d+)/?$}i
+    # The version directory is RbConfig's ruby_version, which development
+    # builds suffix with their ABI version (e.g. "4.1.0+5").
+    RUBY_LIBRARY_PATH_REGEX = %r{/(ruby/(?:site_ruby/|vendor_ruby/)?\d+\.\d+\.\d+(?:\+\d+)?)/?$}i
 
     # Core libraries provided by glibc and the dynamic loader. These must
     # never be bundled: they are tightly coupled to the target system's
@@ -35,6 +37,9 @@ module Ocran
     # payload, which is statically linked and has no dlopen.
     NATIVE_BINARY_EXTENSIONS = %w[.so .bundle .dll].freeze
 
+    # Visual C++ 2015-2022 runtime DLLs (Microsoft.VC14x.CRT redistributables)
+    VC_RUNTIME_DLL_RE = /\A(?:vcruntime140(?:_\d+)?|msvcp140(?:_\w+)?|concrt140|vccorlib140|vcomp140)\.dll\z/i
+
     # Native binaries a gem ships or has had built for it, i.e. the files
     # that make it unusable under the cosmopolitan Ruby payload.
     #
@@ -176,7 +181,48 @@ module Ocran
       else
         require_relative "library_detector_posix"
       end
-      LibraryDetector.loaded_dlls.map { |path| Pathname.new(path).cleanpath }
+      dlls = LibraryDetector.loaded_dlls.map { |path| Pathname.new(path).cleanpath }
+      # A Ruby reached through a junction (the "current" link of rb or
+      # scoop) loads its DLLs by the junction path, while RbConfig reports
+      # the real prefix. Resolve them, or no DLL is recognised as part of
+      # the Ruby installation.
+      dlls.map! { |dll| dll.realpath rescue dll } if Gem.win_platform?
+      dlls
+    end
+
+    # The DLLs that the packed ruby.exe (or rubyw.exe), the Ruby DLL and
+    # the native extensions among +features+ import, directly or through
+    # each other, that are found in the Ruby bin directory, and the Visual
+    # C++ runtime DLLs among them (from the system directory). System DLLs,
+    # and DLLs elsewhere that only the dependency run can find, are not
+    # included.
+    def windows_imported_dlls(features)
+      require_relative "pe_imports"
+
+      bin_dlls = bindir.children.select { |path| path.extname?(".dll") && path.file? }
+                       .to_h { |path| [path.basename.to_s.downcase, path] }
+      system_dir = Pathname((ENV["SystemRoot"] || "C:/Windows").tr("\\", "/")) / "System32"
+      seen = Set.new
+      seen << libruby_so.to_s.downcase if libruby_so
+      found = []
+      queue = [bindir / ruby_executable]
+      queue << bindir / libruby_so if libruby_so
+      queue += features.select { |f| f.extname?(".so") }
+      while (image = queue.shift)
+        next unless image.file?
+
+        PEImports.dll_names(image).each do |name|
+          next unless seen.add?(name.downcase)
+
+          dll = bin_dlls[name.downcase]
+          dll ||= system_dir / name if name.match?(VC_RUNTIME_DLL_RE) && (system_dir / name).file?
+          next unless dll
+
+          found << dll
+          queue << dll
+        end
+      end
+      found
     end
 
     def find_gemspecs(features)
@@ -191,8 +237,7 @@ module Ocran
         end
       end
       if defined?(Gem)
-        foreign = foreign_bundle_gem_names
-        specs += Gem.loaded_specs.each_value.reject { |spec| foreign.include?(spec.name) }
+        specs += application_loaded_specs
         # Now, we also detect gems that are not included in Gem.loaded_specs.
         # Therefore, we look for any loaded file from a gem path.
         specs += GemSpecQueryable.detect_gems_from(features, verbose: @option.verbose?)
@@ -202,6 +247,46 @@ module Ocran
       specs
     end
 
+    # The gems RubyGems had activated when the dependency run ended, less
+    # those that are not the application's.
+    #
+    # Read from the snapshot taken with the loaded features, not from
+    # Gem.loaded_specs, which by now also holds what OCRAN activated for the
+    # build itself - fiddle for DLL detection, tempfile with tmpdir,
+    # fileutils, delegate and etc for the builder - and which every
+    # application used to get packed since 1.3.16 moved the build ahead of
+    # the gem scan. OCRAN's own gem and its runtime dependencies (fiddle) are
+    # dropped as well: the `ocran` command activates them before the
+    # dependency run starts, and since OCRA 1.3.2 they were packed into
+    # every application built from an installed OCRAN, although nothing in a
+    # packaged application loads OCRAN. Only activation is discounted: an
+    # application that does load one of them still gets it packed through
+    # detect_gems_from.
+    def application_loaded_specs
+      @application_loaded_specs ||= begin
+        excluded = foreign_bundle_gem_names | ocran_gem_names
+        @post_env.loaded_specs.reject { |spec| excluded.include?(spec.name) }
+      end
+    end
+
+    # The names of the gem this OCRAN runs from and of the gems it activated
+    # as its runtime dependencies. Empty when OCRAN does not run from an
+    # installed gem, as from a source checkout.
+    def ocran_gem_names
+      specs = @post_env.loaded_specs.to_h { |spec| [spec.name, spec] }
+      own = specs.each_value.find { |spec| Pathname(__dir__).subpath?(spec.gem_dir) }
+      names = Set.new
+      queue = own ? [own] : []
+      while (spec = queue.shift)
+        next unless names.add?(spec.name)
+
+        spec.runtime_dependencies.each do |dep|
+          queue << specs[dep.name] if specs.key?(dep.name)
+        end
+      end
+      names
+    end
+
     # The gems RubyGems had already activated for a bundle that is not the
     # application's, by the time OCRAN started.
     #
@@ -445,8 +530,17 @@ module Ocran
         end
       end
 
+      # Windows-only: DLLs bundled into bin, next to ruby.exe, by basename
+      dlls_in_bin = Set.new
+      add_dll_to_bin = proc do |dll|
+        next if dll.subpath?(bindir) || !dlls_in_bin.add?(dll.basename.to_s.downcase)
+
+        say "Adding detected DLL #{dll} to bin"
+        builder.copy_to_bin(dll, dll.basename)
+      end
+
       # Windows-only: Add detected DLLs
-      if Gem.win_platform? && @option.auto_detect_dlls?
+      if Gem.win_platform? && @option.auto_detect_dlls? && !@option.static_runtime?
         # The Windows loader resolves the imports of a native extension from
         # the extension's own directory, the application directory of the
         # packed ruby.exe (bin) plus its SxS assembly (ruby_builtin_dlls),
@@ -463,16 +557,17 @@ module Ocran
         # LD_LIBRARY_PATH. DLLs from the Windows directory always come from
         # the target system and are never bundled.
         windows_dir = Pathname(ENV["SystemRoot"] || "C:/Windows")
-        dlls_in_bin = Set.new
-        add_dll_to_bin = proc do |dll|
-          next if dll.subpath?(bindir) || !dlls_in_bin.add?(dll.basename.to_s.downcase)
-
-          say "Adding detected DLL #{dll} to bin"
-          builder.copy_to_bin(dll, dll.basename)
-        end
 
         detect_dlls.each do |dll|
           next unless dll.extname?(".dll") && dll.basename != libruby_so
+          # The Visual C++ runtime is not part of Windows: an mswin Ruby
+          # (and any MSVC-built DLL a gem loads) fails to start with
+          # 0xC0000135 where the VC++ Redistributable is not installed.
+          # Microsoft permits deploying it app-locally, next to ruby.exe.
+          if dll.basename.to_s.match?(VC_RUNTIME_DLL_RE)
+            add_dll_to_bin.call(dll)
+            next
+          end
           next if dll.subpath?(windows_dir)
 
           if dll.subpath?(exec_prefix)
@@ -492,7 +587,7 @@ module Ocran
         # the same extension packed at a gem path (openssl and psych are
         # gems since Ruby 3.x) resolves its imports from bin.
         features.select { |f| f.extname?(".so") && f.subpath?(exec_prefix) }
-                .map(&:dirname).uniq
+                .map(&:dirname).uniq { |dir| dir.path_key }
                 .each do |dir|
           dir.each_child do |path|
             next unless path.file? && path.extname?(".dll")
@@ -503,6 +598,25 @@ module Ocran
         end
       end
 
+      # Windows-only: DLLs that ruby.exe, the Ruby DLL and the packed native
+      # extensions import from the Ruby bin directory, plus the Visual C++
+      # runtime. RubyInstaller keeps such DLLs in ruby_builtin_dlls, which is
+      # packed whole below; an mswin Ruby keeps them (gmp, libffi, OpenSSL,
+      # libyaml, zlib from vcpkg) next to ruby.exe, and its interpreter does
+      # not even start without gmp and vcruntime140. They are read from the
+      # PE import tables, so they are packed with --no-autodll too, and for
+      # extensions the dependency run did not exercise.
+      if Gem.win_platform?
+        windows_imported_dlls(features).each do |dll|
+          if dll.subpath?(bindir)
+            verbose "Adding imported DLL #{dll}"
+            builder.duplicate_to_exec_prefix(dll)
+          else
+            add_dll_to_bin.call(dll)
+          end
+        end
+      end
+
       # Linux: bundle detected shared libraries (e.g. libyaml, libssl,
       # libcrypt) next to libruby so the executable also runs on systems
       # where they are missing or have different sonames (the stub already
@@ -510,7 +624,7 @@ module Ocran
       # libraries and the loader are never bundled - they must come from the
       # target system. Ruby native extensions are packed as features, not
       # here. Not needed with --cosmo-ruby: the APE payload is static.
-      if RUBY_PLATFORM.include?("linux") && @option.auto_detect_dlls? && !@option.cosmo_ruby
+      if RUBY_PLATFORM.include?("linux") && @option.auto_detect_dlls? && !@option.cosmo_ruby && !@option.static_runtime?
         feature_set = features.to_set
         feature_realpaths = features.filter_map { |f| f.realpath rescue nil }.to_set
         # Ruby native extensions live in these directories and are packed as
@@ -560,7 +674,7 @@ module Ocran
         archdir = Pathname(RbConfig::CONFIG["archdir"])
         sxs_manifest_dirs << archdir if archdir.exist? && archdir.subpath?(exec_prefix)
         if defined?(Gem)
-          Gem.loaded_specs.each_value do |spec|
+          application_loaded_specs.each do |spec|
             next if spec.extensions.empty?
             ext_dir = Pathname(spec.extension_dir)
             sxs_manifest_dirs << ext_dir if ext_dir.exist? && ext_dir.subpath?(exec_prefix)
@@ -812,7 +926,9 @@ module Ocran
 
         actual_files
       end
-      gem_files.uniq!
+      # Keyed on Pathname#path_key here and below: Array#uniq and Set do not
+      # see the refined, case-insensitive Pathname#eql? on Windows.
+      gem_files.uniq! { |file| file.path_key }
 
       # On some distros parts of a gem are reachable through symlinks at other
       # locations (e.g. Fedora symlinks /usr/share/ruby/psych.rb into the
@@ -820,16 +936,17 @@ module Ocran
       # the same file under different paths. Compare realpaths when removing
       # gem files from the feature list; otherwise a stdlib-level duplicate
       # would be packed as well and shadow the packed gem at runtime.
-      gem_file_set = (gem_files + gem_files.filter_map { |file| file.realpath rescue nil }).to_set
+      gem_file_set = (gem_files + gem_files.filter_map { |file| file.realpath rescue nil })
+                       .to_set { |file| file.path_key }
       features = features.reject do |feature|
-        next true if gem_file_set.include?(feature)
+        next true if gem_file_set.include?(feature.path_key)
 
         real = begin
           feature.realpath
         rescue SystemCallError
           nil
         end
-        real && gem_file_set.include?(real)
+        real && gem_file_set.include?(real.path_key)
       end
 
       # If requested, add all ruby standard libraries
@@ -844,7 +961,6 @@ module Ocran
           end
           path.find.each do |src|
             next if src.directory?
-            a = Pathname(subdir) / src.relative_path_from(path)
             builder.copy_to_lib(src, Pathname(subdir) / src.relative_path_from(path))
           end
         end
@@ -873,7 +989,8 @@ module Ocran
       end
 
       # Windows-only: Workaround for RubyInstaller MSYS folder detection
-      if Gem.win_platform?
+      # (mswin Ruby, built with Visual C++, has no MSYS2 devkit)
+      if Gem.win_platform? && !RUBY_PLATFORM.include?("mswin")
         # RubyInstaller cannot find the msys folder if ../msys64/usr/bin/msys-2.0.dll is not present
         # (since RubyInstaller-2.4.1 rubyinstaller 2 issue 23)
         builder.touch('msys64/usr/bin/msys-2.0.dll')
@@ -1043,7 +1160,7 @@ module Ocran
       neutralize_bundler_env(builder)
       # Add the load path that are required with the correct path after
       # src_prefix was adjusted.
-      load_path = src_load_path.map { |path| SRCDIR / path.relative_path_from(inst_src_prefix) }.uniq
+      load_path = src_load_path.map { |path| SRCDIR / path.relative_path_from(inst_src_prefix) }.uniq { |path| path.path_key }
 
       # On POSIX systems, also add the packed Ruby standard library directories
       # to RUBYLIB. The Ruby binary has a compiled-in prefix pointing to the build
@@ -1082,7 +1199,7 @@ module Ocran
       prefix_gem_dirs = (Gem.path.map { |dir| Pathname(dir) } + [Pathname(Gem.default_dir)])
         .select { |dir| dir.subpath?(exec_prefix) }
         .map { |dir| dir.relative_path_from(exec_prefix) }
-        .uniq
+        .uniq { |dir| dir.path_key }
       gem_paths += prefix_gem_dirs
       # RubyGems probes the default gem dir for writability at startup and
       # prints "Can't determine writability of default gem path" on stderr
@@ -1256,6 +1373,20 @@ module Ocran
       end
     end
 
+    # The PE resource options (version info, string table, manifest), for
+    # every Windows executable the user launches: the self-extracting exe and
+    # the wrapper that installer, directory and zip output start from.
+    def pe_resource_options
+      {
+        version_strings: @option.version_strings,
+        file_version: @option.file_version,
+        product_version: @option.product_version,
+        resource_strings: @option.resource_strings,
+        execution_level: @option.execution_level,
+        application_manifest: @option.application_manifest&.to_s,
+      }
+    end
+
     # Builds the small RUN_IN_EXE_DIR wrapper stub that starts the deployed
     # application directly from the directory the wrapper resides in.
     def build_wrapper_exe(wrapper_path)
@@ -1268,7 +1399,8 @@ module Ocran
                       gui_mode: @option.windowed?,
                       icon_path: @option.icon_filename,
                       run_in_exe_dir: true,
-                      stub_path: cosmo_stub_path) do |stub|
+                      stub_path: cosmo_stub_path,
+                      **pe_resource_options) do |stub|
         yield(stub)
       end
     end
@@ -1278,7 +1410,11 @@ module Ocran
 
       path = Pathname(path)
       say "Building directory #{path}"
-      builder = DirBuilder.new(path, &to_proc)
+      builder = DirBuilder.new(path,
+                               script_name: @option.script.basename.sub_ext("").to_s,
+                               chdir_before: @option.chdir_before?,
+                               chdir_exe_dir: @option.chdir_exe_dir?,
+                               &to_proc)
 
       if @option.wrapper_exe?
         # Same wrapper as in Inno Setup builds: a doubleclickable executable
@@ -1342,30 +1478,41 @@ module Ocran
       end
 
       bundle_id  = @option.bundle_identifier || "com.example.#{app_name}"
-      icon_entry = @option.icon_filename ? "    <key>CFBundleIconFile</key>\n    <string>AppIcon</string>\n" : ""
+      File.write(contents_dir / "Info.plist",
+                 self.class.info_plist(app_name, bundle_id, icon: !!@option.icon_filename))
 
-      File.write(contents_dir / "Info.plist", <<~PLIST)
+      say "Finished building #{bundle_path} (#{builder.data_size} bytes decompressed)"
+    end
+
+    XML_ESCAPES = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;", "'" => "&apos;" }.freeze
+
+    # The Info.plist of a macOS app bundle. The values are XML-escaped: an
+    # app named "R&D" must not produce a property list macOS cannot parse.
+    def self.info_plist(app_name, bundle_id, icon: false)
+      name = app_name.to_s.gsub(/[&<>"']/, XML_ESCAPES)
+      id = bundle_id.to_s.gsub(/[&<>"']/, XML_ESCAPES)
+      icon_entry = icon ? "    <key>CFBundleIconFile</key>\n    <string>AppIcon</string>\n" : ""
+
+      <<~PLIST
         <?xml version="1.0" encoding="UTF-8"?>
         <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
         <plist version="1.0">
         <dict>
           <key>CFBundleName</key>
-          <string>#{app_name}</string>
+          <string>#{name}</string>
           <key>CFBundleDisplayName</key>
-          <string>#{app_name}</string>
+          <string>#{name}</string>
           <key>CFBundleIdentifier</key>
-          <string>#{bundle_id}</string>
+          <string>#{id}</string>
           <key>CFBundleVersion</key>
           <string>1.0</string>
           <key>CFBundlePackageType</key>
           <string>APPL</string>
           <key>CFBundleExecutable</key>
-          <string>#{app_name}</string>
+          <string>#{name}</string>
         #{icon_entry}</dict>
         </plist>
       PLIST
-
-      say "Finished building #{bundle_path} (#{builder.data_size} bytes decompressed)"
     end
 
     # Builds the executable by copying the cosmopolitan Ruby and injecting
@@ -1380,6 +1527,7 @@ module Ocran
       ZipPayloadBuilder.new(output,
                             cosmo_ruby: @option.cosmo_ruby,
                             chdir_before: @option.chdir_before?,
+                            chdir_exe_dir: @option.chdir_exe_dir?,
                             debug_mode: @option.enable_debug_mode?,
                             &to_proc) => builder
 
@@ -1402,6 +1550,56 @@ module Ocran
       say "Finished building #{output} (#{output.size} bytes, #{builder.data_size} bytes of application data)"
     end
 
+    # --static-runtime: the application appended as a ZIP archive to a statically
+    # linked Windows Ruby (see StaticRuntimeBuilder).
+    def build_static_runtime_exe
+      require_relative "static_runtime_builder"
+
+      runtime = StaticRuntime.load(@option.static_runtime)
+      runtime.verify!
+      host_api = RbConfig::CONFIG["ruby_version"]
+      # Gems, default gem specs and the host files the runtime does not
+      # replace were resolved for the build host's Ruby; they only fit a
+      # runtime with the same API version.
+      unless host_api == runtime.ruby_api_version
+        raise "The static runtime in #{runtime.dir} is Ruby #{runtime.ruby_version} (API #{runtime.ruby_api_version}), " \
+              "but this is Ruby #{RUBY_VERSION} (API #{host_api}): package with a Ruby #{runtime.ruby_api_version.sub(/\.0\z/, "")}"
+      end
+      if RUBY_VERSION != runtime.ruby_version
+        warning "Dependency detection ran under Ruby #{RUBY_VERSION}; the static runtime is Ruby #{runtime.ruby_version}"
+      end
+      say "Packaging for the static runtime #{runtime.executable} (Ruby #{runtime.ruby_version} #{runtime.arch})"
+      if @option.extra_dlls.any?
+        warning "--dll has no effect with --static-runtime: a DLL cannot be loaded from inside the executable"
+      end
+
+      output = @option.output_executable
+      StaticRuntimeBuilder.new(output,
+                           runtime: runtime,
+                           host_ruby_api_version: host_api,
+                           host_arch: RbConfig::CONFIG["arch"],
+                           chdir_before: @option.chdir_before?,
+                           chdir_exe_dir: @option.chdir_exe_dir?,
+                           windowed: @option.windowed?,
+                           debug_mode: @option.enable_debug_mode?,
+                           dlls: @option.runtime_dlls,
+                           resources: { icon_path: @option.icon_filename&.to_s, **pe_resource_options },
+                           &to_proc) => builder
+
+      builder.skipped.each do |reason, names|
+        verbose "Not packed (#{reason.to_s.tr("_", " ")}): #{names.size} file(s)"
+        names.each { |name| verbose "\t#{name}" }
+      end
+      unless builder.skipped[:not_in_runtime_stdlib].empty?
+        say "#{builder.skipped[:not_in_runtime_stdlib].size} file(s) of this Ruby's standard library are not " \
+            "in the runtime's and were left out (--verbose lists them)"
+      end
+      say "Finished building #{output} (#{output.size} bytes, #{builder.data_size} bytes of application data)"
+      unless builder.shipped_dlls.empty?
+        say "Ship these DLLs next to #{output.basename}: #{builder.shipped_dlls.map { |d| d.basename.to_s }.join(", ")}"
+      end
+    end
+
     def build_stab_exe
       require_relative "stub_builder"
 
@@ -1418,6 +1616,7 @@ module Ocran
                       gui_mode: @option.windowed?,
                       icon_path: @option.icon_filename,
                       stub_path: cosmo_stub_path,
+                      **pe_resource_options,
                       &to_proc) => builder
       say "Finished building #{@option.output_executable} (#{@option.output_executable.size} bytes)"
       say "After decompression, the data will expand to #{builder.data_size} bytes."