bundlebun 0.2.3.1.3.7-aarch64-linux → 0.4.0.1.3.8-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 547a3cd68b9b57e3f53f6f94283b87e9e6b309db993ba9cd08d5e0da0685342c
-  data.tar.gz: 8d436caaa141ce41d34d068707b5f5abb770540bb265cec247bb6bbb9854f51d
+  metadata.gz: 06ab64db90fe90fd19fb08427c8ca39dee9067d575e296a714da249b9f00e05a
+  data.tar.gz: c80e30e34145a8d6c2ca0da91fd2d1d24c4ebce997baa145ece9bf8c319ab049
 SHA512:
-  metadata.gz: 69b8240e15ea82510da073a6a49506b7f289fb034fdc2718549180eef9f944e75c4183f9110b1756c4631d405da4861b09570e5520fd827284308edc8527cbd4
-  data.tar.gz: 68ed891e75f590f0ff2a55b4647804864dbc556c007122a560ac678f33a76a9cfa087ed039362c58738a1f5356af15748a79065e1bbdf6336f28e759103047cd
+  metadata.gz: 53d74f5e6c44fdc40a36c29d7903ebd044eae559b79c6c8f074c781f1b34e54f1b9fb93f1579bf4ae278b06b278c2ba4f4b879906f8cf746ffcda784e8f608bb
+  data.tar.gz: 34deaf0a237207308a17f13ae82fc6bb87b7eeab57174a7d42ecf0d710a0a1d3e1e42dc28c4d784bc8faf8193255e5199e27a04b784d3972a3e17ac282e265fb

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.4.0] - 2026-02-01
+
+- `Bundlebun.system(args)` method: runs Bun as a subprocess and returns to Ruby. Returns `true` if Bun exited successfully. Use this when you need to continue executing Ruby code after Bun finishes.
+- Default behaviour remains: `Bundlebun.()` / `Bundlebun.call` / `Bundlebun.exec` all replace the current Ruby process with Bun (never return). This is what binstubs and wrappers use.
+
+- ActiveSupport::Notifications instrumentation added. `system.bundlebun` for  `Bundlebun.system` calls, `exec.bundlebun` for exec calls (binstubs, wrappers). Payload: `{ command: args }`.
+- Added RBS type signatures for the public API
+
+## [0.3.0] - 2026-01-29
+
+- New `rake bun:install:package` task: automatically migrates `package.json` scripts to use `bin/bun`. Replaces calls to `bun`, `bunx`, `npx`, `npm run`, `yarn run`, `pnpm run`, and `pnpm exec` with their `bin/bun` equivalents. Asks for confirmation.
+- New `rake bun:install:procfile` task: automatically migrates `Procfile` and `Procfile.*` files to use `bin/bun`. Same as above.
+- Both tasks are automatically invoked by `rake bun:install` when the relevant files are detected.
+
 ## [0.2.3] - 2025-12-17
 
 - Update dependencies

data/README.md

@@ -71,8 +71,8 @@ bundle install
 bundle add bundlebun
 ```
 
-If you're seeing a message like `Could not find gems matching 'bundlebun' valid for all resolution platforms
-(aarch64-linux, aarch64-linux-gnu <...> )`, [check this article](https://github.com/yaroslav/bundlebun/wiki/Could-not-find-gems-matching-'bundlebun'-valid-for-all-resolution-platforms).
+_If you're seeing a message like `Could not find gems matching 'bundlebun' valid for all resolution platforms
+(aarch64-linux, aarch64-linux-gnu <...> )`, [check this article](https://github.com/yaroslav/bundlebun/wiki/Could-not-find-gems-matching-'bundlebun'-valid-for-all-resolution-platforms)._
 
 Next, run:
 
@@ -82,18 +82,83 @@ rake bun:install
 
 The task will install a binstub (`bin/bun`) that you can use to run Bun commands; try running `bin/bun` or `bin/bun --version`.
 
-You should use `bin/bun` in your scripts, including your local runners like `Procfile.dev` or `Procfile`, and `package.json`—if you had a call to `node` or `bun` in the `scripts` section there.
+If `package.json` is present, the installer will offer to migrate your scripts to use `bin/bun` (e.g., `bun` → `bin/bun`, `npx` → `bin/bun x`). You can also run `rake bun:install:package` manually later.
+
+Similarly, if `Procfile` or `Procfile.*` files are present, the installer will offer to migrate those as well. Run `rake bun:install:procfile` manually if needed.
 
 _Windows tip:_ If you're on Windows, the `bin\bun.cmd` file will be created. If you've joined an existing project where only the Unix-like binstub exists at that location, just run `rake bun:install` again.
 
-Next, the Rake task will try to detect the integrations we need to install based on the classes and modules Rake can see in your project. We'll continue with integrations.
+Next, the Rake task will try to detect the integrations we need to install based on the classes and modules Rake can see in your project. See: _Integrations_.
 
 **By default, on load, bundlebun:**
 
 - adds the path to the bundled `bun` executable to the start of your application's `PATH`. That simplifies the integration in cases where we don't really need to monkey-patch a lot of code, and we just need to make sure it "sees" our `bun` executable as available.
 - tries to detect and load all possible integrations.
 
-### Integrations
+## Usage
+
+### Binstub
+
+The easiest way to interact with bundled Bun is via the binstub at `bin/bun`; it will launch the bundled version of Bun with the arguments provided:
+
+```sh
+> bin/bun
+Bun is a fast JavaScript runtime, package manager, bundler, and test runner. (1.1.38+bf2f153f5)
+
+Usage: bun <command> [...flags] [...args]
+
+...
+```
+
+### `PATH`
+
+The bundlebun gem adds the directory with a binary Bun distribution to your `PATH`: prepends it there, to be exact. That helps existing tools that can detect the presence of `bun` executable to find it and work with no further setup or monkey-patching.
+
+### Rake
+
+Alternatively, you can use a Rake task. The syntax is far from perfect, but that's a limitation of Rake. You need to add quotes around the parameters and put them into square brackets. If you cannot install the binstub, though, might be your option.
+
+```
+rake bun[command]  # Run bundled Bun with parameters
+```
+
+```sh
+> rake "bun[outdated]"
+bun outdated v1.1.38 (bf2f153f)
+...
+```
+
+### Ruby
+
+**Check bundlebun API: https://rubydoc.info/gems/bundlebun**.
+
+The easiest way to call Bun from Ruby is via `Bundlebun.()` (shortcut for `Bundlebun.call()`).
+
+**Note:** `Bundlebun.call` replaces the current Ruby process with Bun: it never returns.
+
+```ruby
+Bundlebun.('outdated')             # runs `bun outdated`
+Bundlebun.call(['add', 'postcss']) # runs `bun add postcss`
+```
+
+If you need to run Bun and then continue executing your Ruby code, use `Bundlebun.system`:
+
+```ruby
+if Bundlebun.system('install')
+  puts 'Dependencies installed!'
+else
+  puts 'Installation failed'
+end
+
+# Run tests and check result
+success = Bundlebun.system('test')
+```
+
+Returns `true` if Bun exited successfully, `false` or `nil` otherwise.
+
+Check out the [API documentation](https://rubydoc.info/gems/bundlebun) on `Bundlebun::Runner` for helper methods.
+
+## Integrations
 
 Usually, if you've placed `gem 'bundlebun'` after your frontend-related gems in the `Gemfile`, and did `rake bun:install`, the integrations should all be working out of the box.
 
@@ -158,52 +223,23 @@ Alternatively, you can load the monkey-patch manually:
 Bundlebun::Integrations::ExecJS.bun!
 ```
 
-## Usage
-
-### Binstub
-
-The easiest way to interact with bundled Bun is via the binstub at `bin/bun`; it will launch the bundled version of Bun with the arguments provided:
-
-```sh
-> bin/bun
-Bun is a fast JavaScript runtime, package manager, bundler, and test runner. (1.1.38+bf2f153f5)
-
-Usage: bun <command> [...flags] [...args]
-
-...
-```
-
-### `PATH`
+#### ActiveSupport::Notifications (Instrumentation)
 
-The bundlebun gem adds the directory with a binary Bun distribution to your `PATH`: prepends it there, to be exact. That helps existing tools that can detect the presence of `bun` executable to find it and work with no further setup or monkey-patching.
+When ActiveSupport is available, bundlebun emits instrumentation events that you can subscribe to for logging or monitoring:
 
-### Rake
+- `system.bundlebun` for `Bundlebun.system` (calling Bun and returning to Ruby code);
+- `exec.bundlebun` for `Bundlebun.call` / `Bundlebun.exec` (binstubs and wrappers: exiting to Bun).
 
-Alternatively, you can use a Rake task. The syntax is far from perfect, but that's a limitation of Rake. You need to add quotes around the parameters and put them into square brackets. If you cannot install the binstub, though, might be your option.
+The payload is `{ command: args }`: the arguments you passed to the method (string or array).
 
-```
-rake bun[command]  # Run bundled Bun with parameters
-```
-
-```sh
-> rake "bun[outdated]"
-bun outdated v1.1.38 (bf2f153f)
-...
-```
-
-### Ruby
-
-**Check bundlebun API: https://rubydoc.info/gems/bundlebun**.
-
-The easiest way to call Bun from Ruby would be `Bundlebun.call`:
+Example subscriber:
 
 ```ruby
-Bundlebun.call("outdated") # => `bun outdated`
-Bundlebun.call(["add", "postcss"]) # => `bun add postcss`
+ActiveSupport::Notifications.subscribe('system.bundlebun') do |event|
+  Rails.logger.info "Bun: #{event.payload[:command]} (#{event.duration.round(1)}ms)"
+end
 ```
 
-Check out the [API documentation](https://rubydoc.info/gems/bundlebun) on `Bundlebun::Runner` for helper methods.
-
 ## Versioning
 
 bundlebun uses the `#{bundlebun.version}.#{bun.version}` versioning scheme. Meaning: gem bundlebun version `0.1.0.1.1.38` is a distribution that includes a gem with its own code version `0.1.0` and a Bun runtime with version `1.1.38`.

data/exe/bundlebun

@@ -24,4 +24,4 @@ rescue LoadError
 end
 require 'bundlebun'
 
-Bundlebun::Runner.call(ARGV)
+Bundlebun.call(ARGV)

data/lib/bundlebun/env_path.rb

@@ -31,10 +31,13 @@ module Bundlebun
       def prepend(new_path)
         return if new_path.nil? || new_path.empty?
 
-        path_to_check = Bundlebun::Platform.windows? ? path.downcase : path
-        check_path = Bundlebun::Platform.windows? ? new_path.downcase : new_path
+        already_present = if Bundlebun::Platform.windows?
+          path.downcase.start_with?(new_path.downcase)
+        else
+          path.start_with?(new_path)
+        end
 
-        self.path = "#{new_path}#{separator}#{path}" unless path_to_check.start_with?(check_path)
+        self.path = "#{new_path}#{separator}#{path}" unless already_present
         path
       end
 

data/lib/bundlebun/integrations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundlebun
   # Bundlebun includes several integrations for frontend-related gems and frameworks.
   #

data/lib/bundlebun/runner.rb

@@ -3,29 +3,92 @@
 module Bundlebun
   # {Runner} is the class that bundlebun uses to run the bundled Bun executable.
   #
+  # bundlebun provides two ways to run Bun:
+  #
+  # - {.call} (also available as {.exec}): Replaces the current Ruby process with Bun. This is the default.
+  #
+  # - {.system}: Runs Bun as a subprocess and returns control to Ruby.
+  #   Use this when you need to continue executing Ruby code after Bun finishes.
+  #
   # @see Bundlebun
+  #
+  # @example Running Bun (replaces process, never returns)
+  #   Bundlebun.('install')
+  #   Bundlebun.call('outdated')
+  #   Bundlebun.call(['add', 'postcss'])
+  #
+  # @example Running Bun as subprocess (returns to Ruby)
+  #   if Bundlebun.system('install')
+  #     puts 'Dependencies installed!'
+  #   end
   class Runner
     BINSTUB_PATH = 'bin/bun'
     RELATIVE_DIRECTORY = 'lib/bundlebun/vendor/bun'
 
     class << self
-      # Runs the Bun runtime with parameters.
+      # Replaces the current Ruby process with Bun.
       #
-      # A wrapper for {Bundlebun::Runner.new}, {Bundlebun::Runner.call}.
+      # When `ActiveSupport::Notifications` is available, this method publishes an
+      # `exec.bundlebun` event before replacing the process. The payload contains
+      # `{ command: arguments }` where `arguments` is what was passed to the method.
       #
       # @param arguments [String, Array<String>] Command arguments to pass to Bun
-      # @return [Integer] Exit status code (`127` if executable not found)
+      # @return [void] This method never returns
       #
-      # @example String as an argument
-      #   Bundlebun.call('--version') # => `bun --version`
+      # @example In a binstub (bin/bun)
+      #   #!/usr/bin/env ruby
+      #   require 'bundlebun'
+      #   Bundlebun.exec(ARGV)
+      #
+      # @see .call
+      # @see .system
+      def exec(...)
+        new(...).exec
+      end
+
+      # Replaces the current Ruby process with Bun. Alias for {.exec}.
+      # Also available via the `.()` shorthand syntax.
+      #
+      # @param arguments [String, Array<String>] Command arguments to pass to Bun
+      # @return [void] This method never returns
       #
-      # @example Array of strings as an argument
-      #   Bundlebun.call(['add', 'postcss']) # => `bun add postcss`
+      # @example Basic usage
+      #   Bundlebun.call('outdated')
+      #   Bundlebun.call(['add', 'postcss'])
       #
-      # @see Bundlebun::Runner.new
-      # @see Bundlebun::Runner#call
+      # @example Using the .() shorthand
+      #   Bundlebun.('install')
+      #
+      # @see .exec
+      # @see .system
       def call(...)
-        new(...).call
+        exec(...)
+      end
+
+      # Runs Bun as a subprocess and returns control to Ruby.
+      #
+      # Unlike {.call} and {.exec}, this method does not replace the current process.
+      # Use this when you need to run Bun and then continue executing Ruby code.
+      #
+      # When `ActiveSupport::Notifications` is available, this method publishes a
+      # `system.bundlebun` event with timing information. The payload contains
+      # `{ command: arguments }` where `arguments` is what was passed to the method.
+      #
+      # @param arguments [String, Array<String>] Command arguments to pass to Bun
+      # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+      #   `false` if it exited with an error, `nil` if execution failed
+      #
+      # @example Run install and check result
+      #   if Bundlebun.system('install')
+      #     puts 'Dependencies installed!'
+      #   else
+      #     puts 'Installation failed'
+      #   end
+      #
+      # @see .call
+      # @see .exec
+      def system(...)
+        new(...).system
       end
 
       # A relative path to binstub that bundlebun usually generates with installation Rake tasks.
@@ -98,41 +161,92 @@ module Bundlebun
       end
     end
 
-    # Intialize the {Runner} with arguments to run the Bun runtime later via #call.
+    # Initialize the {Runner} with arguments to run the Bun runtime later.
     #
     # @param arguments [String, Array<String>] Command arguments to pass to Bun
     #
     # @example String as an argument
-    #   Bundlebun::Runner.new('--version') # => `bun --version`
+    #   Bundlebun::Runner.new('--version')
     #
     # @example Array of strings as an argument
-    #   Bundlebun::Runner.new(['add', 'postcss']) # => `bun add postcss`
+    #   Bundlebun::Runner.new(['add', 'postcss'])
     #
-    # @see Bundlebun::Runner#call
+    # @see #system
+    # @see #exec
     def initialize(arguments = '')
       @arguments = arguments
     end
 
-    # Runs the Bun executable with previously specified arguments.
+    # Replaces the current Ruby process with Bun.
+    # This is the default behavior.
     #
-    # Check other methods of {Bundlebun::Runner} to see how we determine what to run exactly.
+    # When `ActiveSupport::Notifications` is available, this method publishes an
+    # `exec.bundlebun` event before replacing the process. The payload contains
+    # `{ command: arguments }` where `arguments` is what was passed to the runner.
     #
-    # @return [Integer] Exit status code (`127` if executable not found)
+    # @return [void] This method never returns
     #
     # @example
-    #   b = Bundlebun::Runner.new('--version')
-    #   b.call
+    #   runner = Bundlebun::Runner.new(ARGV)
+    #   runner.exec  # Ruby process ends here, Bun takes over
     #
-    # @see Bundlebun::Runner
+    # @see #system
+    def exec
+      check_executable!
+      instrument('exec.bundlebun')
+      Kernel.exec(command)
+    end
+
+    # Replaces the current Ruby process with Bun. Alias for {#exec}.
+    #
+    # @return [void] This method never returns
+    #
+    # @see #exec
     def call
+      exec
+    end
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    #
+    # Unlike {#call} and {#exec}, this method does not replace the current process.
+    # Use this when you need to run Bun and then continue executing Ruby code.
+    #
+    # When `ActiveSupport::Notifications` is available, this method publishes a
+    # `system.bundlebun` event with timing information. The payload contains
+    # `{ command: arguments }` where `arguments` is what was passed to the runner.
+    #
+    # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+    #   `false` if it exited with an error, `nil` if execution failed
+    #
+    # @example
+    #   runner = Bundlebun::Runner.new('install')
+    #   if runner.system
+    #     puts 'Dependencies installed!'
+    #   end
+    #
+    # @see #exec
+    def system
       check_executable!
-      exec(command)
+      instrument('system.bundlebun') do
+        Kernel.system(command)
+      end
     end
 
     private
 
     attr_reader :arguments
 
+    def instrument(event, &block)
+      return block&.call unless defined?(ActiveSupport::Notifications)
+
+      payload = {command: arguments}
+      if block
+        ActiveSupport::Notifications.instrument(event, payload, &block)
+      else
+        ActiveSupport::Notifications.instrument(event, payload)
+      end
+    end
+
     def check_executable!
       return if self.class.binary_path_exist?
 

data/lib/bundlebun/version.rb

@@ -8,5 +8,5 @@ module Bundlebun
   # a Bun runtime with version `1.1.38`.
   #
   # This constant always points to the "own" version of the gem.
-  VERSION = '0.2.3'
+  VERSION = '0.4.0'
 end

data/lib/bundlebun.rb

@@ -9,28 +9,84 @@ require 'zeitwerk'
 # bundlebun includes binary distributions of Bun for each of the supported
 # platforms (macOS, Linux, Windows) and architectures.
 #
+# bundlebun provides two ways to run Bun:
+#
+# - {.call} (also available as {.exec}): Replaces the current Ruby process with Bun. The default.
+#
+# - {.system}: Runs Bun as a subprocess and returns control to Ruby.
+#   Use this when you need to continue executing Ruby code after Bun finishes.
+#
 # @see Bundlebun::Runner
 # @see Bundlebun::Integrations
+#
+# @example Running Bun (replaces process, never returns)
+#   Bundlebun.('install')                # .() shorthand syntax
+#   Bundlebun.call('outdated')
+#   Bundlebun.call(['add', 'postcss'])
+#
+# @example Running Bun as subprocess (returns to Ruby)
+#   if Bundlebun.system('install')
+#     puts 'Dependencies installed!'
+#   end
 module Bundlebun
   class << self
-    # Runs the Bun runtime with parameters.
+    # Replaces the current Ruby process with Bun.
     #
-    # A shortcut for {Bundlebun::Runner.call}.
+    # This is the default way to run Bun. The Ruby process is replaced by Bun
+    # and never returns. Also available via the `.()` shorthand syntax.
     #
     # @param arguments [String, Array<String>] Command arguments to pass to Bun
-    # @return [Integer] Exit status code (`127` if executable not found)
+    # @return [void] This method never returns
     #
-    # @example String as an argument
-    #   Bundlebun.call('--version') # => `bun --version`
+    # @example Basic usage
+    #   Bundlebun.call('outdated')
+    #   Bundlebun.call(['add', 'postcss'])
     #
-    # @example Array of strings as an argument
-    #   Bundlebun.call(['add', 'postcss']) # => `bun add postcss`
+    # @example Using the .() shorthand
+    #   Bundlebun.('install')
+    #   Bundlebun.(ARGV)
     #
+    # @see .exec
+    # @see .system
     # @see Bundlebun::Runner.call
     def call(...)
       Runner.call(...)
     end
 
+    # Replaces the current Ruby process with Bun. Same as {.call}.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    # @return [void] This method never returns
+    #
+    # @see .call
+    # @see Bundlebun::Runner.exec
+    def exec(...)
+      Runner.exec(...)
+    end
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    #
+    # Unlike {.call} and {.exec}, this method does not replace the current process.
+    # Use this when you need to run Bun and then continue executing Ruby code.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+    #   `false` if it exited with an error, `nil` if execution failed
+    #
+    # @example Run install and check result
+    #   if Bundlebun.system('install')
+    #     puts 'Dependencies installed!'
+    #   else
+    #     puts 'Installation failed'
+    #   end
+    #
+    # @see .call
+    # @see .exec
+    # @see Bundlebun::Runner.system
+    def system(...)
+      Runner.system(...)
+    end
+
     def loader # @private
       @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
         loader.ignore("#{__dir__}/tasks")

data/lib/tasks/bun.rake

@@ -17,5 +17,5 @@ require 'rake'
 desc 'Run bundled Bun with parameters. Example: rake "bun[build]"'
 task :bun, [:command] do |_t, args|
   command = args[:command] || ''
-  Bundlebun::Runner.call(command)
+  Bundlebun.call(command)
 end

data/lib/tasks/install.rake

@@ -26,6 +26,16 @@ namespace :bun do
       puts "vite-ruby detected.\n\n"
       Rake::Task['bun:install:vite'].invoke
     end
+
+    if File.exist?('package.json')
+      puts "package.json detected.\n\n"
+      Rake::Task['bun:install:package'].invoke
+    end
+
+    if Dir.glob('Procfile*').any?
+      puts "Procfile detected.\n\n"
+      Rake::Task['bun:install:procfile'].invoke
+    end
   end
 
   desc 'Install bundlebun: create `bin/bun` binstub'
@@ -170,4 +180,126 @@ namespace :bun do
 
     MESSAGE
   end
+
+  desc 'Migrate package.json scripts to use bin/bun'
+  task 'install:package' do
+    package_json_path = 'package.json'
+
+    unless File.exist?(package_json_path)
+      puts "No package.json found in the current directory."
+      next
+    end
+
+    begin
+      package = JSON.parse(File.read(package_json_path))
+    rescue JSON::ParserError
+      puts "Failed to parse package.json."
+      next
+    end
+
+    scripts = package['scripts']
+    if scripts.nil? || scripts.empty?
+      puts "No scripts found in package.json."
+      next
+    end
+
+    # Order in alternation matters: more specific patterns first
+    pattern = /\b(bunx|npx|pnpm exec|yarn exec|npm run|yarn run|pnpm run|bun)\b/
+    binstub = Bundlebun::Runner.binstub_path
+    replacements = {
+      'bunx' => "#{binstub} x",
+      'npx' => "#{binstub} x",
+      'pnpm exec' => "#{binstub} x",
+      'yarn exec' => "#{binstub} x",
+      'npm run' => "#{binstub} run",
+      'yarn run' => "#{binstub} run",
+      'pnpm run' => "#{binstub} run",
+      'bun' => binstub
+    }
+
+    changes = []
+    scripts.each do |name, value|
+      next unless value.is_a?(String)
+      next if value.include?(Bundlebun::Runner::BINSTUB_PATH)
+
+      new_value = value.gsub(pattern) { |match| replacements[match] }
+      changes << {name: name, old: value, new: new_value} if new_value != value
+    end
+
+    if changes.empty?
+      puts "All scripts in package.json already use bin/bun. No changes needed."
+      next
+    end
+
+    puts "The following changes will be made to package.json scripts:\n\n"
+    changes.each do |change|
+      puts "  #{change[:name]}:"
+      puts "    - #{change[:old]}"
+      puts "    + #{change[:new]}"
+      puts
+    end
+
+    print "Apply these changes? [Y/n] "
+    answer = $stdin.gets&.strip&.downcase
+
+    if answer.empty? || answer == 'y' || answer == 'yes'
+      changes.each do |change|
+        package['scripts'][change[:name]] = change[:new]
+      end
+
+      File.write(package_json_path, JSON.pretty_generate(package) + "\n")
+      puts "\nUpdated package.json successfully."
+    else
+      puts "\nNo changes made."
+    end
+  end
+
+  desc 'Migrate Procfile commands to use bin/bun'
+  task 'install:procfile' do
+    procfiles = Dir.glob('Procfile*')
+
+    if procfiles.empty?
+      puts "No Procfile found in the current directory."
+      next
+    end
+
+    pattern = /\b(bunx|npx|pnpm exec|yarn exec|npm run|yarn run|pnpm run|bun)\b/
+    binstub = Bundlebun::Runner.binstub_path
+    replacements = {
+      'bunx' => "#{binstub} x",
+      'npx' => "#{binstub} x",
+      'pnpm exec' => "#{binstub} x",
+      'yarn exec' => "#{binstub} x",
+      'npm run' => "#{binstub} run",
+      'yarn run' => "#{binstub} run",
+      'pnpm run' => "#{binstub} run",
+      'bun' => binstub
+    }
+
+    procfiles.each do |procfile|
+      content = File.read(procfile)
+      next if content.include?(Bundlebun::Runner::BINSTUB_PATH)
+
+      new_content = content.gsub(pattern) { |match| replacements[match] }
+      next if new_content == content
+
+      puts "Changes for #{procfile}:\n\n"
+      content.lines.zip(new_content.lines).each do |old_line, new_line|
+        if old_line != new_line
+          puts "  - #{old_line}"
+          puts "  + #{new_line}"
+        end
+      end
+
+      print "Apply these changes? [Y/n] "
+      answer = $stdin.gets&.strip&.downcase
+
+      if answer.empty? || answer == 'y' || answer == 'yes'
+        File.write(procfile, new_content)
+        puts "Updated #{procfile} successfully.\n\n"
+      else
+        puts "No changes made to #{procfile}.\n\n"
+      end
+    end
+  end
 end

data/sig/bundlebun/env_path.rbs

@@ -0,0 +1,8 @@
+module Bundlebun
+  class EnvPath
+    def self.path: () -> String?
+    def self.path=: (String new_path) -> String
+    def self.prepend: (String new_path) -> String?
+    def self.separator: () -> String
+  end
+end

data/sig/bundlebun/integrations/cssbundling.rbs

@@ -0,0 +1,12 @@
+module Bundlebun
+  module Integrations
+    module Cssbundling
+      def self.bun!: () -> void
+
+      module Tasks
+        def install_command: () -> String
+        def build_command: () -> String
+      end
+    end
+  end
+end

data/sig/bundlebun/integrations/execjs.rbs

@@ -0,0 +1,7 @@
+module Bundlebun
+  module Integrations
+    module ExecJS
+      def self.bun!: () -> void
+    end
+  end
+end

data/sig/bundlebun/integrations/jsbundling.rbs

@@ -0,0 +1,12 @@
+module Bundlebun
+  module Integrations
+    module Jsbundling
+      def self.bun!: () -> void
+
+      module Tasks
+        def install_command: () -> String
+        def build_command: () -> String
+      end
+    end
+  end
+end

data/sig/bundlebun/integrations/vite_ruby.rbs

@@ -0,0 +1,12 @@
+module Bundlebun
+  module Integrations
+    module ViteRuby
+      def self.bun!: () -> void
+
+      module RunnerExtensions
+        def vite_executable: (*untyped exec_args) -> Array[String]
+        def bun_binstub_path: () -> String
+      end
+    end
+  end
+end

data/sig/bundlebun/integrations.rbs

@@ -0,0 +1,5 @@
+module Bundlebun
+  module Integrations
+    def self.bun!: () -> Array[Module]
+  end
+end

data/sig/bundlebun/platform.rbs

@@ -0,0 +1,5 @@
+module Bundlebun
+  class Platform
+    def self.windows?: () -> bool
+  end
+end

data/sig/bundlebun/runner.rbs

@@ -0,0 +1,35 @@
+module Bundlebun
+  class Runner
+    BINSTUB_PATH: String
+    RELATIVE_DIRECTORY: String
+
+    # Replaces the current Ruby process with Bun. Never returns.
+    def self.exec: (String | Array[String] arguments) -> bot
+
+    # Replaces the current Ruby process with Bun. Alias for .exec. Never returns.
+    def self.call: (String | Array[String] arguments) -> bot
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    def self.system: (String | Array[String] arguments) -> bool?
+
+    def self.binstub_path: () -> String
+    def self.full_binstub_path: () -> String
+    def self.relative_directory: () -> String
+    def self.full_directory: () -> String
+    def self.binary_path: () -> String
+    def self.binary_path_exist?: () -> bool
+    def self.binstub_or_binary_path: () -> String
+    def self.binstub_exist?: () -> bool
+
+    def initialize: (?String | Array[String] arguments) -> void
+
+    # Replaces the current Ruby process with Bun. Never returns.
+    def exec: () -> bot
+
+    # Replaces the current Ruby process with Bun. Alias for #exec. Never returns.
+    def call: () -> bot
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    def system: () -> bool?
+  end
+end

data/sig/bundlebun/version.rbs

@@ -0,0 +1,3 @@
+module Bundlebun
+  VERSION: String
+end

data/sig/bundlebun.rbs

@@ -0,0 +1,18 @@
+module Bundlebun
+  VERSION: String
+
+  # Replaces the current Ruby process with Bun.
+  # This is the default way to run Bun. Never returns.
+  def self.call: (String | Array[String] arguments) -> bot
+
+  # Replaces the current Ruby process with Bun. Same as .call.
+  def self.exec: (String | Array[String] arguments) -> bot
+
+  # Runs Bun as a subprocess and returns control to Ruby.
+  # Returns true if Bun exited successfully, false if it failed, nil if execution failed.
+  def self.system: (String | Array[String] arguments) -> bool?
+
+  def self.prepend_to_path: () -> String?
+  def self.load_tasks: () -> void
+  def self.load_integrations: () -> Array[Module]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundlebun
 version: !ruby/object:Gem::Version
-  version: 0.2.3.1.3.7
+  version: 0.4.0.1.3.8
 platform: aarch64-linux
 authors:
 - Yaroslav Markin
@@ -13,30 +13,30 @@ dependencies:
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 description: 'bundlebun bundles Bun, a fast JavaScript runtime, package manager, and
   builder, with your Ruby and Rails applications. No need to use Docker, devcontainers,
   `curl | sh`, or `brew`.
@@ -71,6 +71,16 @@ files:
 - lib/templates/bundling-rails/bundlebun.rake
 - lib/templates/vite-ruby/bun-vite
 - lib/templates/vite-ruby/vite.json
+- sig/bundlebun.rbs
+- sig/bundlebun/env_path.rbs
+- sig/bundlebun/integrations.rbs
+- sig/bundlebun/integrations/cssbundling.rbs
+- sig/bundlebun/integrations/execjs.rbs
+- sig/bundlebun/integrations/jsbundling.rbs
+- sig/bundlebun/integrations/vite_ruby.rbs
+- sig/bundlebun/platform.rbs
+- sig/bundlebun/runner.rbs
+- sig/bundlebun/version.rbs
 homepage: https://github.com/yaroslav/bundlebun
 licenses:
 - MIT
@@ -80,6 +90,7 @@ metadata:
   changelog_uri: https://github.com/yaroslav/bundlebun/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/yaroslav/bundlebun/issues
   documentation_uri: https://rubydoc.info/gems/bundlebun
+  rbs_source: sig
 post_install_message: Bun.
 rdoc_options: []
 require_paths: