bundlebun 0.3.0.1.3.8-aarch64-linux → 0.4.0.1.3.8-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94afccb6c525baa5ea69ca947d3406e90d5de9d9c1f692f5c9f5607e5cc38c16
-  data.tar.gz: 9692d8653ca2e56d0961455468fc1c27200d0bf035dfe172bbca7974f2d30023
+  metadata.gz: 06ab64db90fe90fd19fb08427c8ca39dee9067d575e296a714da249b9f00e05a
+  data.tar.gz: c80e30e34145a8d6c2ca0da91fd2d1d24c4ebce997baa145ece9bf8c319ab049
 SHA512:
-  metadata.gz: d4626312c43a65adf12e9164aa6123e11bdd792c12e265545d9f1f34d71d7a937d04ad718c9a39642a427ac2da276942cdfadc555c76beac10e09b9a4c5ba535
-  data.tar.gz: 9d0cd2fae203e1dd3b9a015a5f49e226fc103f157019dbb167d9d3de732b16adad8663ea6006454ae249e3843745fdca48d1863a5ef07e5987de4a494730f993
+  metadata.gz: 53d74f5e6c44fdc40a36c29d7903ebd044eae559b79c6c8f074c781f1b34e54f1b9fb93f1579bf4ae278b06b278c2ba4f4b879906f8cf746ffcda784e8f608bb
+  data.tar.gz: 34deaf0a237207308a17f13ae82fc6bb87b7eeab57174a7d42ecf0d710a0a1d3e1e42dc28c4d784bc8faf8193255e5199e27a04b784d3972a3e17ac282e265fb

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [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.

data/README.md

@@ -88,14 +88,77 @@ Similarly, if `Procfile` or `Procfile.*` files are present, the installer will o
 
 _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.
 
@@ -160,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.3.0'
+  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/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.3.0.1.3.8
+  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: