ocran 1.4.3 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23bee04c3290671dc55673fcb757a222e04af6977bd015a0791bab76ef492f1c
-  data.tar.gz: a4d437bda8e4bd00ea4a66c9c75c2aaa85b6904b8c7619e4f04a5e2b931688d5
+  metadata.gz: 79aa33b2625758b6cce7b1175d45d73c5c60209b996a6d5ab03a4df55acbae28
+  data.tar.gz: 3d53ff8c8b7a31448080f105f33af4968dea8f9a8fd559aa92a9e87db31db0dd
 SHA512:
-  metadata.gz: 0bd96938ab10206fe5009d93d9356034cbb9913159507b51f0df1fa4d46f428fbf7ae0c75ce1e8359079af70094ab8b68d64671064a59ec8bda313baf863dc79
-  data.tar.gz: 199615b364954980946418e4c850e9153cf2a2aabf4a5475143e08ff8bbeeda4dcb784a2fb578ef07b9559b8ae37b24103b36f99e4f86c96357674a115c371a6
+  metadata.gz: e9975e649595c77397e49649544fad56b209917a55f7ea6d7ff7acf748a14608165013fbe1e43908946b0cba1badbae22da7b73aac4ba2661fb092162d333386
+  data.tar.gz: 67007f4112f91a8bb6a01564a8b5b4b54edd2b852a629f78d1bc12bd9062e3a71771fe0a802bc9f3133560cd0aa7da18fa912f0eb0f2f8337288ea226be308b2

data/CHANGELOG.txt

@@ -1,3 +1,22 @@
+=== 1.4.4
+- Fix crash on distro-packaged and Homebrew Ruby when a default gem (e.g. fiddle, singleton) has a gemspec but no materialized gem directory: file collection now treats the missing directory as an empty set instead of raising Errno::ENOENT from Find.find (issue #44). The gem's files, which live in the stdlib, are still packed via the load path.
+- Pack the real Ruby interpreter when bindir/ruby is a dispatcher script (e.g. Fedora's rubypick): the running interpreter binary (/proc/self/exe) is packed under the expected name instead, so the packed executable no longer requires Ruby on the target system.
+- Build runtime RUBYLIB from the build Ruby's actual default load path in addition to the RbConfig directories, covering distro-specific compiled-in entries such as Fedora's /usr/share/rubygems where rubygems.rb lives outside rubylibdir.
+- Include every Gem.path entry under the Ruby prefix in the runtime GEM_PATH (not just Gem.default_dir), so RubyGems can activate gems from split layouts like Fedora's /usr/share/gems + /usr/local/share/gems.
+- Make default gems activatable at runtime: their gemspecs (from specifications/default/, which RubyGems only scans under the compiled-in Gem.default_dir) are also copied into the regular specifications directory of the same packed base directory.
+- Handle distros that expose gem files under additional symlinked paths (e.g. Fedora symlinks /usr/share/ruby/psych.rb into the psych gem directory): loaded features are resolved by realpath so they are packed inside the gem directory, and duplicate stdlib-level copies that would shadow the packed gem at runtime are no longer packed.
+- Pack native extension files that distros build outside the gem's base_dir (e.g. Fedora's /usr/lib64/gems/ruby) into the extension directory RubyGems computes at runtime, and recreate the gem.build_complete marker there so the gem activates instead of being ignored ("its extensions are not built").
+- Linux: bundle detected non-glibc shared libraries (libyaml, libssl, libcrypt, libgmp, libz, ...) next to libruby, with soname symlink aliases, so packed executables also run on other distros where these are missing or have different sonames. Core glibc libraries, the loader, and libnss_* plugins are never bundled; the target's glibc must be at least as new as the build host's. Disable with --no-autodll.
+- CI: new isolated workflow test-aspera-cli.yml that packages the aspera-cli gem with distro Ruby on Fedora and verifies the executable runs on clean Fedora and Ubuntu containers without Ruby. Kept separate from the release pipeline with a read-only token; the third-party gem only ever runs inside throwaway containers.
+- Restore the OCRA-compatible wrapper executable for Inno Setup builds: `--innosetup` now additionally builds a small stub executable named after `--output` and installs it into `{app}` alongside the application files. The wrapper runs the installed application directly from its own directory (new RUN_IN_EXE_DIR stub mode) — no extraction, no cleanup of the application directory. This behavior existed in OCRA and ocran <= 1.3.x but was lost in the 1.4.0 rewrite, breaking user ISS scripts that reference the executable, e.g. in [Run]/[UninstallRun] entries or for Windows service registration (`myapp.exe --register-service`). The launcher.bat is still generated and installed as before.
+- Add `run_in_exe_dir` option to StubBuilder and a RUN_IN_EXE_DIR (0x20) stub header flag. In this mode the stub never deletes its directory (double-guarded in the stub itself, since the directory is the real application directory).
+- Allow `--innosetup` on POSIX hosts when an ISCC command is available in PATH (e.g. a Wine wrapper); previously it was rejected on non-Windows unconditionally. Fix the ISCC presence check to use `command -v` instead of the Windows-only `where`/`>NUL` on POSIX.
+- Inno Setup builds from POSIX hosts no longer crash on symlink entries (symlinks cannot be expressed in an installer script and are skipped; they are only generated for POSIX shared-library aliases).
+- `--output-dir` and `--output-zip` now also include the wrapper executable (named after `--output`) next to the launch script, so the unpacked output has a doubleclickable, pinnable, signable entry point that can even be registered as a Windows service. The launch script (`.bat`/`.sh`) is still generated.
+- New `--no-wrapper-exe` option: omit the wrapper executable from installer, directory and zip output.
+- Always create the packed prefix gem directories (e.g. lib/ruby/gems/<api>) even when empty: RubyGems probes the default gem dir for writability at startup and printed "Can't determine writability of default gem path" on stderr for every packed executable on newer RubyGems.
+- Stub: normalize the extraction/application directory to its long path form on Windows (GetLongPathName). With an 8.3 short TEMP path (e.g. C:\Users\RUNNER~1) the same file could be loaded under two spellings, defeating $LOADED_FEATURES deduplication and causing "already initialized constant" warnings.
+
 === 1.4.3
 - Migrate edicon from C to Ruby: replace edicon.exe with a pure-Ruby implementation (ed_icon.rb), fixing incorrect BeginUpdateResource error checking and wrong GroupIconSize calculation. Shortens build times and removes the C binary from the build.
 - Include Gem.default_dir in GEM_PATH on all platforms: previously the exec_prefix gem directory was excluded on Windows, causing native-extension gems (e.g. fxruby/fox16) to fail at runtime with a LoadError even though they were bundled correctly.

data/README.md

@@ -1,11 +1,6 @@
-# ocran
+# OCRAN
 
-home   :: https://github.com/largo/ocran/
-issues :: http://github.com/largo/ocran/issues
-
-## Description
-
-OCRAN (One-Click Ruby Application Next) packages Ruby applications for
+[OCRAN (One-Click Ruby Application Next)](https://github.com/largo/ocran) packages Ruby applications for
 distribution. It bundles your script, the Ruby interpreter, gems, and native
 libraries into a single self-contained artifact that runs without requiring
 Ruby to be installed on the target machine.
@@ -20,6 +15,8 @@ OCRAN supports four output formats, all cross-platform:
 OCRAN is a fork of [OCRA](https://github.com/larsch/ocra) maintained for
 Ruby 3.2+ compatibility.
 
+If you run into errors while using OCRAN, please check the [OCRAN issues](https://github.com/largo/ocran/issues) first.
+
 ## Recommended usage
 
 The most common use-case is shipping a program to users running Windows / Linux / macOS
@@ -34,7 +31,8 @@ If using Windows you can use  the Inno Setup
 option (`--innosetup`) to produce a proper installer that extracts once to a
 permanent directory.
 
-You can easily generate binaries for the supported Operating Systems with GitHub Actions.
+You can easily generate binaries for the supported Operating Systems with GitHub
+Actions — see [Building for multiple platforms with GitHub Actions](#building-for-multiple-platforms-with-github-actions).
 
 ## Features
 
@@ -238,7 +236,92 @@ OCRAN on the same platform (and architecture) as the intended target**:
 There is no support for building a Windows `.exe` from a Linux or macOS host,
 or vice versa. If you need builds for multiple platforms, run OCRAN in CI on
 each target platform separately (e.g., a Windows runner for `.exe` builds and
-a Linux runner for Linux builds).
+a Linux runner for Linux builds). See
+[Building for multiple platforms with GitHub Actions](#building-for-multiple-platforms-with-github-actions)
+for a ready-made setup.
+
+### Linux binary portability (glibc)
+
+On Linux, OCRAN bundles the shared libraries your application loaded during
+the build (libyaml, libssl, libcrypt, libgmp, libz, ...) next to the bundled
+Ruby, so the executable also runs on distributions where those libraries are
+missing or have different sonames. It works with distro-packaged Ruby too
+(e.g. `dnf install ruby` on Fedora), including its split gem layout and
+`rubypick` wrapper.
+
+One thing can never be bundled: **glibc itself** (and its dynamic loader).
+Those always come from the target system, and glibc is only
+backward-compatible. In practice:
+
+* A Linux binary runs on any distribution whose glibc is **at least as new**
+  as the build machine's.
+* Build on the **oldest** distribution you want to support. For example, a
+  binary built on the oldest available `ubuntu-*` GitHub runner runs on that
+  Ubuntu version and everything newer, while a binary built on a
+  cutting-edge distribution (e.g. `fedora:latest`) will not run on older
+  Debian/Ubuntu releases (`` version `GLIBC_2.4x' not found ``).
+
+Use `--no-autodll` to disable shared library bundling.
+
+## Building for multiple platforms with GitHub Actions
+
+Since OCRAN is not a cross-compiler, the recommended way to ship your app for
+Windows, Linux, and macOS is a GitHub Actions matrix that runs OCRAN natively
+on each platform. A minimal workflow:
+
+```yaml
+name: Build binaries
+
+on:
+  push:
+    tags: ['v*']      # build releases from version tags
+  workflow_dispatch:   # allow manual runs
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest   # x86-64 Windows .exe
+          - os: ubuntu-22.04     # x86-64 Linux; oldest runner = widest glibc compatibility
+          - os: macos-14         # Apple Silicon macOS
+          - os: macos-15-intel   # Intel macOS
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true    # if your app has a Gemfile
+
+      - run: gem install ocran
+
+      # Run OCRAN on your entry script. Add "-- <args>" if your script needs
+      # arguments to exit cleanly during the dependency-detection run.
+      - run: ocran myapp.rb --output myapp
+        # produces myapp.exe on Windows, myapp on Linux/macOS
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: myapp-${{ matrix.os }}
+          path: myapp*
+```
+
+Notes:
+
+* Pick the **oldest** `ubuntu-*` runner GitHub offers for the Linux build so
+  the binary runs on as many distributions as possible (see
+  [Linux binary portability](#linux-binary-portability-glibc)).
+* On macOS, each architecture needs its own build: `macos-14` (and newer
+  numbered ARM runners) produce Apple Silicon binaries, `macos-15-intel`
+  produces Intel binaries.
+* Swap the `ocran` invocation for `--output-dir`, `--output-zip`,
+  `--macosx-bundle`, or `--innosetup` depending on how you want to ship
+  (see [Recommended usage](#recommended-usage)).
+* For tag pushes you can attach the artifacts to a GitHub release with a
+  follow-up job (e.g. `softprops/action-gh-release`).
 
 ## Requirements
 
@@ -320,8 +403,12 @@ If your script uses `Kernel#autoload`, OCRAN will attempt to load those
 constants so they are included in the output. Missing modules are ignored
 with a warning.
 
-Dynamic link libraries (.dll files, for example WxWidgets, or other
-source files) will be detected and included by OCRAN.
+Dynamic link libraries are detected and included by OCRAN: `.dll` files on
+Windows (for example WxWidgets), and on Linux the non-glibc shared libraries
+the process loaded (libyaml, libssl, libcrypt, ...), which are placed next to
+the bundled Ruby with appropriate soname symlinks (see
+[Linux binary portability](#linux-binary-portability-glibc)). Disable with
+`--no-autodll`.
 
 ### Including libraries non-automatically
 
@@ -534,10 +621,12 @@ file:
 
 ## Credits
 
-Lars Christensen and contributors for the OCRA project which this is forked from.
+[Andi Idogawa](https://github.com/largo), [Shinokaro](https://github.com/shinokaro)
+[Lars Christensen](https://github.com/larsch) and contributors for the OCRA project which this is forked from.
+
+Special thanks to Ruby on Windows maintainers such as [Nobuyoshi Nakada](https://github.com/nobu), [Lars Kanis](https://github.com/larskanis), and [MSP-Greg](https://github.com/MSP-Greg)
 
-Kevin Walzer of codebykevin, Maxim Samsonov for ocra2, John Mair for
-codesigning support.
+[Kevin Walzer](https://github.com/codebykevin) of codebykevin, [Maxim Samsonov](https://github.com/maxirmx), and [John Mair](https://github.com/banister) for codesigning support.
 
 Igor Pavlov for the LZMA compressor and decompressor (Public Domain).
 
@@ -551,7 +640,7 @@ http://ruby.morphball.net/vit-ruby-ico_en.html).
 (The MIT License)
 
 Copyright (c) 2009-2020 Lars Christensen
-Copyright (c) 2020-2025 The OCRAN Committers Team
+Copyright (c) 2020-2026 The OCRAN Committers Team
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/ocran/build_facade.rb

@@ -10,6 +10,8 @@ module Ocran
 
     def cp(...) = @filer.__send__(__method__, ...)
 
+    def symlink(...) = @filer.__send__(__method__, ...)
+
     def export(...) = @launcher.__send__(__method__, ...)
 
     def exec(...) = @launcher.__send__(__method__, ...)

data/lib/ocran/dir_builder.rb

@@ -13,6 +13,9 @@ module Ocran
     WINDOWS = Gem.win_platform?
 
     attr_reader :data_size
+    # Recorded launch data (environment variables and exec arguments), used
+    # by Direction to build the optional wrapper executable.
+    attr_reader :env, :exec_args
 
     def initialize(path)
       @path = Pathname(path)

data/lib/ocran/direction.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "rbconfig"
 require "pathname"
+require "set"
 require_relative "refine_pathname"
 require_relative "host_config_helper"
 require_relative "command_output"
@@ -17,6 +18,12 @@ module Ocran
     # - /ruby/vendor_ruby/3.0.0/
     RUBY_LIBRARY_PATH_REGEX = %r{/(ruby/(?:site_ruby/|vendor_ruby/)?\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
+    # ld.so, and shipping a foreign copy breaks the dynamic linker. The
+    # libnss_* plugins are dlopened by the target's glibc and must match it.
+    LINUX_SYSTEM_LIBRARY_RE = /\A(?:ld-linux|ld64|libc\.so|libm\.so|libdl\.so|libpthread\.so|librt\.so|libutil\.so|libnsl\.so|libresolv\.so|libmvec\.so|libanl\.so|libBrokenLocale\.so|libnss_)/
+
     include BuildConstants, CommandOutput, HostConfigHelper
 
     attr_reader :ruby_executable, :rubyopt
@@ -168,7 +175,20 @@ module Ocran
 
       # Add the ruby executable and DLL
       say "Adding ruby executable #{ruby_executable}"
-      builder.copy_to_bin(bindir / ruby_executable, ruby_executable)
+      ruby_source = bindir / ruby_executable
+      if !Gem.win_platform? && File.binread(ruby_source, 2) == "#!"
+        # On some distros (e.g. Fedora), bindir/ruby is a dispatcher shell
+        # script ("rubypick") rather than the interpreter itself, which
+        # cannot run on a system without Ruby. Pack the currently running
+        # interpreter binary under the expected name instead.
+        real_ruby = Pathname("/proc/self/exe")
+        raise "#{ruby_source} is a wrapper script and the real interpreter could not be determined" unless real_ruby.exist?
+
+        say "#{ruby_source} is a wrapper script; packing #{real_ruby.realpath} instead"
+        builder.copy_to_bin(real_ruby.realpath, ruby_executable)
+      else
+        builder.copy_to_bin(ruby_source, ruby_executable)
+      end
       if libruby_so
         # On POSIX systems, libruby.so is in libdir; on Windows, it's in bindir
         libruby_src = Gem.win_platform? ? bindir / libruby_so : libdir / libruby_so
@@ -221,6 +241,44 @@ module Ocran
         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
+      # points LD_LIBRARY_PATH at the packed bin directory). Core glibc
+      # libraries and the loader are never bundled - they must come from the
+      # target system. Ruby native extensions are packed as features, not
+      # here.
+      if RUBY_PLATFORM.include?("linux") && @option.auto_detect_dlls?
+        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
+        # features; they must not be duplicated into bin.
+        ruby_arch_dirs = RbConfig::CONFIG.values_at("archdir", "sitearchdir", "vendorarchdir")
+          .compact.map { |dir| Pathname(dir) }
+        detect_dlls.each do |dll|
+          basename = dll.basename.to_s
+          next unless basename.match?(/\.so(\.|\z)/)
+          next if basename.match?(LINUX_SYSTEM_LIBRARY_RE)
+          # libruby is packed with its aliases already
+          next if basename.start_with?("libruby")
+          next if feature_set.include?(dll) || feature_realpaths.include?(dll)
+          next if ruby_arch_dirs.any? { |dir| dll.subpath?(dir) } || dll.to_posix.match?(%r{/gems/})
+          next unless dll.file?
+
+          say "Adding detected shared library #{dll}"
+          builder.copy_to_bin(dll, basename)
+          # The loader may request a library by a less specific soname than
+          # the fully versioned file name recorded in the memory map (e.g.
+          # libssl.so.3 for libssl.so.3.2.4). Provide symlink aliases for
+          # each shorter version suffix.
+          alias_name = basename
+          while (shorter = alias_name.sub(/\.\d+[^.]*\z/, "")) != alias_name && shorter.include?(".so")
+            builder.symlink_in_bin(basename, shorter)
+            alias_name = shorter
+          end
+        end
+      end
+
       # Windows-only: Add external manifest and builtin DLLs
       if Gem.win_platform?
         if (manifest = ruby_builtin_manifest)
@@ -284,6 +342,45 @@ module Ocran
           raise "Gem spec #{spec_file} does not exist in the Ruby installation. Don't know where to put it."
         end
 
+        spec_dir = spec_file.dirname
+        default_spec = spec_dir.basename.to_s == "default"
+        # The gem's base directory: specs live in <base_dir>/specifications[/default]
+        base_dir = default_spec ? spec_dir.dirname.dirname : spec_dir.dirname
+        # Relative packed location of base_dir; nil when the gem lives outside
+        # the Ruby prefix, in which case its files are packed under GEMDIR
+        # with the same layout.
+        packed_base = base_dir.subpath?(exec_prefix) ? base_dir.relative_path_from(exec_prefix) : GEMDIR
+
+        # Default gemspecs live in a "specifications/default" directory, which
+        # RubyGems only scans under Gem.default_dir. On rubies with a
+        # compiled-in absolute prefix (e.g. distro Ruby on Fedora), that path
+        # points to the build host and does not exist on the target system, so
+        # activating such a gem (e.g. via a binstub) fails. Also place a copy
+        # in the regular specifications directory of the same packed base
+        # directory, where GEM_PATH makes it discoverable and its require
+        # paths resolve to the packed gem files.
+        if !Gem.win_platform? && default_spec
+          builder.cp(spec_file, packed_base / "specifications" / spec_file.basename)
+        end
+
+        # Native-extension gems record successful builds in a gem.build_complete
+        # marker under <base_dir>/extensions/...; without it RubyGems refuses to
+        # activate the gem ("Ignoring x because its extensions are not built").
+        # The marker can be absent from the packed tree either because the
+        # distro relocates it (e.g. Fedora keeps it under /usr/lib64/gems/ruby
+        # via a default_ext_dir_for override) or because the gem is a default
+        # gem, which is exempt from the check on the host while its packed
+        # regular-spec copy is not. Recreate the marker where RubyGems expects
+        # it at runtime.
+        if !Gem.win_platform? && spec.extensions.any?
+          api_version = Gem.respond_to?(:extension_api_version) ? Gem.extension_api_version : Gem.ruby_api_version
+          packed_ext_dir = Pathname("extensions") / Gem::Platform.local.to_s / api_version / spec.full_name
+          host_marker = Pathname(spec.gem_build_complete_path)
+          if default_spec || (File.exist?(host_marker) && !host_marker.subpath?(base_dir))
+            builder.touch(packed_base / packed_ext_dir / "gem.build_complete")
+          end
+        end
+
         # Determine which set of files to include for this particular gem
         include = GemSpecQueryable.gem_inclusion_set(spec.name, @option.gem_options)
         say "Detected gem #{spec.full_name} (#{include.join(", ")})"
@@ -292,6 +389,9 @@ module Ocran
 
         verbose "\tgem_dir: #{spec.gem_dir}"
         verbose "\tgem_dir exists: #{File.directory?(spec.gem_dir)}"
+        unless File.directory?(spec.gem_dir)
+          verbose "\tGem directory does not exist (default gem?); packing loaded files via load path instead"
+        end
         loaded_matches = include.include?(:loaded) ? features.select { |f| f.subpath?(spec.gem_dir) } : []
         verbose "\t:loaded candidates in features: #{loaded_matches.size}"
         loaded_matches.each { |f| verbose "\t  loaded: #{f}" }
@@ -313,11 +413,72 @@ module Ocran
           end
         end
 
+        # When a distro builds native extensions outside the gem's base_dir
+        # and loads them from there (e.g. Fedora's /usr/lib64/gems/ruby), the
+        # loaded .so would be packed at a mirror path that is never on the
+        # runtime load path. Pack such loaded extension files ONLY into the
+        # extension directory RubyGems computes at runtime, which gem
+        # activation puts on the load path. Appended to actual_files after
+        # the generic copy above so they are claimed as gem files (and thus
+        # excluded from the plain feature packing, where a bare .so on
+        # RUBYLIB would shadow the gem) without also being mirrored at their
+        # host location. The extension dir and the load location may be
+        # aliased via symlinks in either direction, so match features against
+        # the extension dir by realpath both ways.
+        if !Gem.win_platform? && spec.extensions.any?
+          host_ext_dir = Pathname(spec.extension_dir)
+          if host_ext_dir.directory? && !host_ext_dir.subpath?(base_dir)
+            alias_map = {}
+            host_ext_dir.find.select(&:file?).each do |entry|
+              real = begin
+                entry.realpath
+              rescue SystemCallError
+                next
+              end
+              alias_map[real] = entry
+            end
+            features.each do |feature|
+              real = begin
+                feature.realpath
+              rescue SystemCallError
+                feature
+              end
+              entry = if feature.subpath?(host_ext_dir)
+                        feature
+                      elsif real.subpath?(host_ext_dir)
+                        real
+                      else
+                        alias_map[feature] || alias_map[real]
+                      end
+              next unless entry
+
+              builder.cp(feature, packed_base / packed_ext_dir / entry.relative_path_from(host_ext_dir))
+              actual_files << feature
+            end
+          end
+        end
+
         actual_files
       end
       gem_files.uniq!
 
-      features -= gem_files
+      # 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
+      # psych gem directory), so a feature and a packed gem file can denote
+      # 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
+      features = features.reject do |feature|
+        next true if gem_file_set.include?(feature)
+
+        real = begin
+          feature.realpath
+        rescue SystemCallError
+          nil
+        end
+        real && gem_file_set.include?(real)
+      end
 
       # If requested, add all ruby standard libraries
       if @option.add_all_core?
@@ -500,13 +661,16 @@ module Ocran
       # By adding the extract-dir equivalents of rubylibdir, sitelibdir, etc. to
       # RUBYLIB, Ruby can find rubygems and the standard library in the packed tree.
       unless Gem.win_platform?
-        core_lib_paths = all_core_dir
+        # Use the build Ruby's actual default load path in addition to the
+        # RbConfig directories: some distros compile in extra entries that
+        # RbConfig does not expose (e.g. Fedora's /usr/share/rubygems, where
+        # rubygems.rb lives outside rubylibdir).
+        default_load_paths = @pre_env.load_path.map { |dir| Pathname(@pre_env.expand_path(dir)) }
+        archdir = Pathname(RbConfig::CONFIG["archdir"])
+        core_lib_paths = (default_load_paths + all_core_dir + [archdir])
           .select { |dir| dir.subpath?(exec_prefix) }
           .map { |dir| dir.relative_path_from(exec_prefix) }
-        archdir = Pathname(RbConfig::CONFIG["archdir"])
-        if archdir.subpath?(exec_prefix)
-          core_lib_paths << archdir.relative_path_from(exec_prefix)
-        end
+          .uniq
         load_path = core_lib_paths + load_path
       end
 
@@ -515,15 +679,24 @@ module Ocran
 
       gem_paths = [GEMDIR]
       # Gems installed under the Ruby prefix (exec_prefix) have their specs and
-      # extension dirs placed there via duplicate_to_exec_prefix. Include
-      # Gem.default_dir (relative to exec_prefix) in GEM_PATH so RubyGems can
-      # find and activate them at runtime. This is required on both Windows
-      # (e.g. fxruby/fox16 whose fox16_c.so lives in extension_dir under the
-      # Ruby prefix) and POSIX (e.g. error_highlight default gems).
-      default_gem_dir = Pathname(Gem.default_dir)
-      if default_gem_dir.subpath?(exec_prefix)
-        gem_paths << default_gem_dir.relative_path_from(exec_prefix)
-      end
+      # extension dirs placed there via duplicate_to_exec_prefix. Include every
+      # Gem.path entry located under exec_prefix (relative to it) in GEM_PATH so
+      # RubyGems can find and activate them at runtime. This is required on both
+      # Windows (e.g. fxruby/fox16 whose fox16_c.so lives in extension_dir under
+      # the Ruby prefix) and POSIX (e.g. error_highlight default gems). Distros
+      # can split gems over several such directories - e.g. Fedora uses
+      # /usr/share/gems for RPM-packaged (default) gems and /usr/local/share/gems
+      # for user-installed ones - so Gem.default_dir alone is not enough.
+      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
+      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
+      # when the directory does not exist in the packed layout - so always
+      # create the packed prefix gem dirs, even when no specs landed there.
+      prefix_gem_dirs.each { |dir| builder.mkdir(dir) }
       builder.set_env_path("GEM_PATH", *gem_paths)
 
       # Add the opcode to launch the script
@@ -546,8 +719,13 @@ module Ocran
         title: @option.output_executable.basename.sub_ext("")
       )
 
+      # Record the launch events (exports + exec) so they can be replayed
+      # into the wrapper stub executable below.
+      require_relative "launcher_event_recorder"
+      recorder = LauncherEventRecorder.new(launcher_builder)
+
       require_relative "build_facade"
-      builder = BuildFacade.new(iss_builder, launcher_builder)
+      builder = BuildFacade.new(iss_builder, recorder)
 
       if @option.icon_filename
         builder.cp(@option.icon_filename, File.basename(@option.icon_filename))
@@ -560,22 +738,65 @@ module Ocran
       verbose File.read(launcher_path)
       builder.cp(launcher_path, "launcher.bat")
 
-      say "Build inno setup script file"
-      iss_path = iss_builder.build
-      verbose File.read(iss_path)
+      require "tmpdir"
+      Dir.mktmpdir("ocran") do |tmpdir|
+        if @option.wrapper_exe?
+          # Wrapper executable (pre-1.4/OCRA behavior): a small stub without
+          # embedded files that runs the installed application directly from
+          # {app}. It is installed next to the application files so that user
+          # Inno Setup scripts can reference it by the --output name, e.g. in
+          # [Run]/[UninstallRun] entries or for Windows service registration.
+          wrapper_path = Pathname(tmpdir) / @option.output_executable.basename
+          build_wrapper_exe(wrapper_path) { |stub| recorder.replay(stub) }
+          builder.cp(wrapper_path, wrapper_path.basename)
+        end
+
+        say "Build inno setup script file"
+        iss_path = iss_builder.build
+        verbose File.read(iss_path)
 
-      say "Running Inno Setup Command-Line compiler (ISCC)"
-      iss_builder.compile(verbose: @option.verbose?)
+        say "Running Inno Setup Command-Line compiler (ISCC)"
+        iss_builder.compile(verbose: @option.verbose?)
+      end
 
       say "Finished building installer file"
     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)
+      require_relative "stub_builder"
+      say "Build wrapper executable #{wrapper_path.basename}"
+      StubBuilder.new(wrapper_path,
+                      chdir_before: @option.chdir_before?,
+                      debug_mode: @option.enable_debug_mode?,
+                      gui_mode: @option.windowed?,
+                      icon_path: @option.icon_filename,
+                      run_in_exe_dir: true) do |stub|
+        yield(stub)
+      end
+    end
+
     def build_output_dir(path)
       require_relative "dir_builder"
 
       path = Pathname(path)
       say "Building directory #{path}"
-      DirBuilder.new(path, &to_proc)
+      builder = DirBuilder.new(path, &to_proc)
+
+      if @option.wrapper_exe?
+        # Same wrapper as in Inno Setup builds: a doubleclickable executable
+        # next to the launch script, usable e.g. for Windows service
+        # registration from an unpacked zip. Disable with --no-wrapper-exe.
+        build_wrapper_exe(path / @option.output_executable.basename) do |stub|
+          builder.env.each { |name, value| stub.export(name, value) }
+          if builder.exec_args
+            image, script, argv = builder.exec_args
+            stub.exec(image, script, *argv)
+          end
+        end
+      end
+
       say "Finished building directory #{path}"
     end
 

data/lib/ocran/gem_spec_queryable.rb

@@ -131,8 +131,11 @@ module Ocran
 
     def gem_root = Pathname(gem_dir)
 
-    # Find the selected files
-    def gem_root_files = gem_root.find.select(&:file?)
+    # Find the selected files. Default gems (e.g. fiddle, singleton on
+    # Homebrew or distro-packaged Ruby) may have a gemspec without a
+    # materialized gem directory - their files live in Ruby's stdlib and
+    # are packed via the load path instead.
+    def gem_root_files = gem_root.directory? ? gem_root.find.select(&:file?) : []
 
     def script_files
       gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
@@ -154,7 +157,25 @@ module Ocran
         when :spec
           files.map { |file| Pathname(file) }
         when :loaded
-          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
+          # Some distros expose gem files under additional paths via symlinks
+          # (e.g. Fedora symlinks /usr/share/ruby/psych.rb into the psych gem
+          # directory) and $LOADED_FEATURES records the symlink path. Resolve
+          # each feature to its realpath so such files count as gem files and
+          # are packed inside the gem directory. Packing them at the symlink
+          # location instead would break require_relative, which resolves
+          # against the realpath on the build host but not in the packed app.
+          features_from_gems.filter_map do |feature|
+            if feature.subpath?(gem_dir)
+              feature
+            else
+              real = begin
+                feature.realpath
+              rescue SystemCallError
+                next
+              end
+              real if real.subpath?(gem_dir)
+            end
+          end
         when :files
           resource_files
         when :extras

data/lib/ocran/inno_setup_script_builder.rb

@@ -14,7 +14,14 @@ module Ocran
 
     class << self
       def compile(iss_filename, quiet: false)
-        unless Gem.win_platform? || system("where #{quote_and_escape(ISCC_CMD)} >NUL 2>&1")
+        # "where" and ">NUL" only exist on Windows; use "command -v" on POSIX
+        # (e.g. when testing the pipeline with a fake ISCC on Linux/macOS).
+        iscc_found = if Gem.win_platform?
+                       true # ISCC is invoked directly; failure is reported below
+                     else
+                       system("command -v #{quote_and_escape(ISCC_CMD)} > /dev/null 2>&1")
+                     end
+        unless iscc_found
           raise "ISCC command not found. Is the InnoSetup directory in your PATH?"
         end
 
@@ -79,6 +86,13 @@ module Ocran
       @dirs.add?("/", target)
     end
 
+    # Symbolic links cannot be expressed in an Inno Setup script. They only
+    # occur when building from POSIX hosts (e.g. libruby.so links); Windows
+    # installations do not need them, so they are skipped.
+    def symlink(_target, _link_name)
+      nil
+    end
+
     def cp(source, target)
       unless File.exist?(source)
         raise "The file does not exist (#{source})"

data/lib/ocran/launcher_event_recorder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ocran
+  # Records launcher-directed build events (environment exports and the
+  # application exec command) while forwarding them to another launcher
+  # builder. The recorded events can later be replayed into a further
+  # builder — e.g. to produce a wrapper stub executable alongside the
+  # launcher batch file in Inno Setup builds.
+  class LauncherEventRecorder
+    def initialize(launcher)
+      @launcher = launcher
+      @events = []
+    end
+
+    def export(name, value)
+      @events << [:export, name, value]
+      @launcher.export(name, value)
+    end
+
+    def exec(image, script, *argv)
+      @events << [:exec, image, script, *argv]
+      @launcher.exec(image, script, *argv)
+    end
+
+    def replay(builder)
+      @events.each { |event, *args| builder.public_send(event, *args) }
+    end
+  end
+end

data/lib/ocran/option.rb

@@ -37,6 +37,7 @@ module Ocran
         :source_files => [],
         :verbose? => false,
         :warning? => true,
+        :wrapper_exe? => true,
       }
     end
 
@@ -90,6 +91,8 @@ Output options:
 --output <file>    Name the exe to generate. Defaults to ./<scriptname>.exe.
 --output-dir <dir> Output all files to a directory with a launch script instead of an exe.
 --output-zip <file> Output a zip archive containing all files and a launch script.
+--no-wrapper-exe   Do not add the wrapper executable to installer, directory or
+                   zip output (a launch script is always included there).
 --macosx-bundle    Build a macOS .app bundle. Use --output to name it (default: <scriptname>.app).
 --bundle-id <id>   Bundle identifier for the macOS app bundle (default: com.example.<appname>).
 --no-lzma          Disable LZMA compression of the executable.
@@ -125,6 +128,8 @@ EOF
         when "--output-zip"
           path = argv.shift
           @options[:output_zip] = Pathname.new(path).expand_path if path
+        when "--no-wrapper-exe"
+          @options[:wrapper_exe?] = false
         when "--macosx-bundle"
           @options[:macosx_bundle?] = true
         when "--bundle-id"
@@ -301,6 +306,8 @@ EOF
 
     def quiet? = @options[__method__]
 
+    def wrapper_exe? = @options[__method__]
+
     def rubyopt = @options[__method__]
 
     def run_script? = @options[__method__]

data/lib/ocran/runner.rb

@@ -94,10 +94,12 @@ module Ocran
       direction = Direction.new(@post_env, @pre_env, @option)
 
       if @option.use_inno_setup?
-        if Gem.win_platform?
+        # Native on Windows; on POSIX allow it when an ISCC command is
+        # available (e.g. via Wine wrapper scripts or in tests).
+        if Gem.win_platform? || system("command -v ISCC > /dev/null 2>&1")
           direction.build_inno_setup_installer
         else
-          raise "Inno Setup is only supported on Windows"
+          raise "Inno Setup is only supported on Windows (no ISCC command found in PATH)"
         end
       elsif @option.macosx_bundle
         direction.build_macosx_bundle(@option.macosx_bundle)

data/lib/ocran/stub_builder.rb

@@ -20,6 +20,7 @@ module Ocran
     AUTO_CLEAN_INST_DIR = 0x04
     CHDIR_BEFORE_SCRIPT = 0x08
     DATA_COMPRESSED     = 0x10
+    RUN_IN_EXE_DIR      = 0x20
 
     WINDOWS = Gem.win_platform?
 
@@ -95,8 +96,16 @@ module Ocran
     # icon_path:
     # Specifies the path to the icon file to be embedded in the stub's resources.
     #
+    # run_in_exe_dir:
+    # When set to true, the stub runs the application directly from its own
+    # directory instead of extracting to a temporary directory. Used for
+    # installer (Inno Setup) wrapper executables where the application files
+    # are installed next to the stub (pre-1.4/OCRA behavior). The directory
+    # is never deleted on exit.
+    #
     def initialize(path, chdir_before: nil, debug_extract: nil, debug_mode: nil,
-                   enable_compression: nil, gui_mode: nil, icon_path: nil)
+                   enable_compression: nil, gui_mode: nil, icon_path: nil,
+                   run_in_exe_dir: nil)
       @dirs = FilePathSet.new
       @files = FilePathSet.new
       @data_size = 0
@@ -129,7 +138,7 @@ module Ocran
         @of = of
         @opcode_offset = @of.size
 
-        write_header(debug_mode, debug_extract, chdir_before, enable_compression)
+        write_header(debug_mode, debug_extract, chdir_before, enable_compression, run_in_exe_dir)
 
         b = proc {
           yield(self)
@@ -213,14 +222,20 @@ module Ocran
     end
     private :compress
 
-    def write_header(debug_mode, debug_extract, chdir_before, compressed)
+    def write_header(debug_mode, debug_extract, chdir_before, compressed, run_in_exe_dir = nil)
       next_to_exe, delete_after = debug_extract, !debug_extract
+      if run_in_exe_dir
+        # Wrapper mode: run in place next to the executable — never extract,
+        # and (critically) never delete the application directory on exit.
+        next_to_exe, delete_after = false, false
+      end
       @of << [0 |
                 (debug_mode ? DEBUG_MODE : 0) |
                 (next_to_exe ? EXTRACT_TO_EXE_DIR : 0) |
                 (delete_after ? AUTO_CLEAN_INST_DIR : 0) |
                 (chdir_before ? CHDIR_BEFORE_SCRIPT : 0) |
-                (compressed ? DATA_COMPRESSED : 0)
+                (compressed ? DATA_COMPRESSED : 0) |
+                (run_in_exe_dir ? RUN_IN_EXE_DIR : 0)
       ].pack("C")
     end
     private :write_header

data/lib/ocran/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ocran
-  VERSION = "1.4.3"
+  VERSION = "1.4.4"
 end

data/src/inst_dir.c

@@ -98,8 +98,50 @@ const char *CreateInstDir(bool is_extract_to_exe_dir)
         return NULL;
     }
 
-    InstDir = inst_dir;
-    return inst_dir;
+    /* Normalize 8.3 short names (e.g. a TEMP under C:\Users\RUNNER~1) so all
+       paths derived from the extraction dir use one consistent spelling. */
+    char *long_dir = ToLongPath(inst_dir);
+    free(inst_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
+}
+
+// Sets the installation directory to the executable's own directory
+// (installer/wrapper mode, RUN_IN_EXE_DIR). No directory is created and
+// the directory must never be deleted by the stub.
+const char *SetInstDirToExeDir(void)
+{
+    if (InstDir != NULL) {
+        APP_ERROR("Installation directory has already been set");
+        return NULL;
+    }
+
+    char *image_path = GetImagePath();
+    if (!image_path) {
+        APP_ERROR("Failed to get executable name");
+        return NULL;
+    }
+
+    char *image_dir = GetParentPath(image_path);
+    free(image_path);
+    if (!image_dir) {
+        APP_ERROR("Failed to obtain the directory path of the executable file");
+        return NULL;
+    }
+
+    /* Normalize 8.3 short names for a consistent spelling (see CreateInstDir) */
+    char *long_dir = ToLongPath(image_dir);
+    free(image_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
 }
 
 // Frees the allocated memory for the installation directory path.

data/src/inst_dir.h

@@ -20,6 +20,20 @@
  */
 const char *CreateInstDir(bool is_extract_to_exe_dir);
 
+/**
+ * @brief Sets the installation directory to the executable's own directory.
+ *
+ * Unlike CreateInstDir, no new directory is created: the stub runs the
+ * application directly from the directory the executable resides in
+ * (installer/wrapper mode, RUN_IN_EXE_DIR). The directory must never be
+ * deleted by the stub.
+ *
+ * @return
+ *   A pointer to the directory path if successful, NULL if an error
+ *   occurred. The returned path should not be freed by the caller.
+ */
+const char *SetInstDirToExeDir(void);
+
 /**
  * @brief Free the allocated installation directory path
  *        and reset the internal pointer to NULL.

data/src/stub.c

@@ -57,15 +57,24 @@ int main(int argc, char *argv[])
         DEBUG("Ocran stub running in debug mode");
     }
 
-    /* Create extraction directory */
-    extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
-    if (!extract_dir) {
-        FATAL("Failed to create extraction directory");
-        goto cleanup;
+    /* Create extraction directory, or run in place next to the executable
+       (installer/wrapper mode, see RUN_IN_EXE_DIR) */
+    if (IsRunInExeDir(op_modes)) {
+        extract_dir = SetInstDirToExeDir();
+        if (!extract_dir) {
+            FATAL("Failed to resolve the executable directory");
+            goto cleanup;
+        }
+        DEBUG("Running in executable directory: %s", extract_dir);
+    } else {
+        extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
+        if (!extract_dir) {
+            FATAL("Failed to create extraction directory");
+            goto cleanup;
+        }
+        DEBUG("Created extraction directory: %s", extract_dir);
     }
 
-    DEBUG("Created extraction directory: %s", extract_dir);
-
     /* Unpacking process */
     if (!ProcessImage(unpack_ctx)) {
         FATAL("Failed to unpack image due to invalid or corrupted data");
@@ -120,7 +129,9 @@ cleanup:
     /*
        If AUTO_CLEAN_INST_DIR is set, delete the extraction directory.
     */
-    if (IsAutoCleanInstDir(op_modes)) {
+    /* Never delete in RUN_IN_EXE_DIR mode: the "installation directory"
+       is the real application directory, not a temporary extraction dir. */
+    if (IsAutoCleanInstDir(op_modes) && !IsRunInExeDir(op_modes)) {
         DEBUG("Deleting extraction directory: %s", extract_dir);
         if (!DeleteInstDir()) {
             DEBUG("Failed to delete extraction directory");

data/src/system_utils.c

@@ -96,6 +96,32 @@ char *JoinPath(const char *p1, const char *p2)
     return joined_path;
 }
 
+char *ToLongPath(const char *path)
+{
+    if (!path) {
+        return NULL;
+    }
+
+    DWORD required = GetLongPathName(path, NULL, 0);
+    if (required == 0) {
+        return _strdup(path); /* e.g. path does not exist - keep as is */
+    }
+
+    char *buf = malloc(required);
+    if (!buf) {
+        APP_ERROR("Memory allocation failed for long path");
+        return NULL;
+    }
+
+    DWORD written = GetLongPathName(path, buf, required);
+    if (written == 0 || written >= required) {
+        free(buf);
+        return _strdup(path);
+    }
+
+    return buf;
+}
+
 char *GetParentPath(const char *path)
 {
     if (!path) {

data/src/system_utils.h

@@ -102,6 +102,20 @@ char *GetImagePath(void);
  */
 char *GetTempDirectoryPath(void);
 
+/**
+ * @brief Normalizes a path to its long form.
+ *
+ * On Windows, converts 8.3 short names (e.g. "C:\\Users\\RUNNER~1") to the
+ * full long path via GetLongPathName. Two spellings of the same directory
+ * would otherwise defeat Ruby's $LOADED_FEATURES deduplication, causing
+ * files to be loaded twice ("already initialized constant" warnings).
+ * On POSIX this simply returns a copy of the given path.
+ *
+ * @return A newly allocated string (caller frees), or NULL on allocation
+ *         failure. Falls back to a copy of the input if conversion fails.
+ */
+char *ToLongPath(const char *path);
+
 /**
  * @brief Writes the contents of a buffer to the specified file path.
  *        Creates any missing parent directories and overwrites existing files.

data/src/system_utils_posix.c

@@ -498,3 +498,9 @@ bool CreateAndWaitForProcess(const char *app_name, char *argv[], int *exit_code)
 
     return true;
 }
+
+/* POSIX has no short-path aliases - return a plain copy. */
+char *ToLongPath(const char *path)
+{
+    return path ? strdup(path) : NULL;
+}

data/src/unpack.c

@@ -536,6 +536,10 @@ bool IsDataCompressed(OperationModes modes) {
     return IsMode(modes, DATA_COMPRESSED);
 }
 
+bool IsRunInExeDir(OperationModes modes) {
+    return IsMode(modes, RUN_IN_EXE_DIR);
+}
+
 bool ProcessImage(const UnpackContext *context)
 {
     if (!context) {

data/src/unpack.h

@@ -66,6 +66,14 @@ typedef enum {
      * required before using the data.
      */
     DATA_COMPRESSED     = 0x10,
+
+    /**
+     * Runs the application directly from the executable's own directory
+     * instead of creating an extraction directory. Used by installer builds
+     * (e.g. Inno Setup) where the application files are installed next to
+     * the stub executable. Restores the pre-1.4 (OCRA) wrapper behavior.
+     */
+    RUN_IN_EXE_DIR      = 0x20,
 } OperationModes;
 
 bool IsDebugMode(OperationModes modes);
@@ -73,6 +81,7 @@ bool IsExtractToExeDir(OperationModes modes);
 bool IsAutoCleanInstDir(OperationModes modes);
 bool IsChdirBeforeScript(OperationModes modes);
 bool IsDataCompressed(OperationModes modes);
+bool IsRunInExeDir(OperationModes modes);
 
 typedef struct UnpackContext UnpackContext;
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocran
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.4.4
 platform: ruby
 authors:
 - Andi Idogawa
@@ -25,27 +25,13 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: |
-  OCRAN (One-Click Ruby Application Next) packages Ruby applications for
-  distribution. It bundles your script, the Ruby interpreter, gems, and native
-  libraries into a self-contained artifact that runs without requiring Ruby to
-  be installed on the target machine.
-
-  Three output formats are supported on all platforms:
-  - Self-extracting executable (.exe on Windows, native binary on Linux/macOS)
-  - Directory with a launch script (--output-dir)
-  - Zip archive with a launch script (--output-zip)
-
-  This is a fork of OCRA maintained for Ruby 3.2+ compatibility.
-  Migration guide: replace OCRA_EXECUTABLE with OCRAN_EXECUTABLE in your code.
-
-  Usage:
-    ocran helloworld.rb          # builds helloworld.exe / helloworld
-    ocran --output-dir out/ app.rb
-    ocran --output-zip app.zip app.rb
-
-  See readme at https://github.com/largo/ocran
-  Report problems at https://github.com/largo/ocran/issues
+description: 'OCRAN (One-Click Ruby Application Next) packages Ruby applications for
+  distribution on Windows, Linux, and macOS. It bundles your script, the Ruby interpreter,
+  gems, and native libraries into a self-contained artifact that runs without Ruby
+  installed on the target machine: a self-extracting executable (default), a directory
+  (--output-dir), a zip archive (--output-zip), or a macOS .app bundle (--macosx-bundle).
+  Fork of OCRA maintained for Ruby 3.2+; migrating code should replace OCRA_EXECUTABLE
+  with OCRAN_EXECUTABLE.'
 email:
 - andi@idogawa.com
 executables:
@@ -73,6 +59,7 @@ files:
 - lib/ocran/host_config_helper.rb
 - lib/ocran/inno_setup_script_builder.rb
 - lib/ocran/launcher_batch_builder.rb
+- lib/ocran/launcher_event_recorder.rb
 - lib/ocran/library_detector.rb
 - lib/ocran/library_detector_posix.rb
 - lib/ocran/option.rb
@@ -110,7 +97,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/largo/ocran
   source_code_uri: https://github.com/largo/ocran
-  changelog_uri: https://github.com/largo/ocran/CHANGELOG.txt
+  changelog_uri: https://github.com/largo/ocran/blob/master/CHANGELOG.txt
 rdoc_options: []
 require_paths:
 - lib
@@ -125,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: OCRAN (One-Click Ruby Application Next) packages Ruby applications for distribution
   on Windows, Linux, and macOS.