bundlebun 0.5.0.1.3.13-aarch64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6142fa5f87f08ab0c546236b979120cefe3f131483c39c14bac19b62d837794c
+  data.tar.gz: 709ea8c7db3aebbab2e3708a202185926682ed1ea8e5da5d9d6e288dc4881b6e
+SHA512:
+  metadata.gz: b9b209bccbac818f68cf8ae5f1b156c5d6a6497e6ec47d2df3172e0721ac5513c5f012e8f440b40465a06176d2cb72146c9e154870c60ba7cdbd25b05836bd31
+  data.tar.gz: a7d466831d2e25ecebbed25f19a622e4123c6169d6b902ee5a5fdc1dbb42850f69b253fe08837a3398625eb1fb65ab04888454df8cc6a0497f585c18eddd8196

data/CHANGELOG.md

@@ -0,0 +1,69 @@
+## [0.5.0] - 2026-04-30
+
+- Now including Bun builds for `linux-musl` Linux variants [#16].
+- Existing Linux variants are now labeled as `linux-gnu`
+- No code changes.
+
+## [0.4.2] - 2026-04-12
+
+- It makes no sense to run Bun without arguments, so no-argument `Bundlebun.call` / `exec` / `system` calls now raise `ArgumentError`.
+- `Bundlebun::Runner.binstub_path` and `full_binstub_path` are now memoized, matching the existing pattern used by `binary_path` and `full_directory`. Avoids redundant string and `File.expand_path` work on every integration command build.
+
+## [0.4.1] - 2026-03-08
+
+- Bun is now executed with argv-safe `exec` / `system` calls instead of flattening arguments into a single string to preserve values with spaces correctly.
+- `rake bun:install:package` and `rake bun:install:procfile` no longer crash in non-interactive environments when stdin is closed.
+
+## [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
+- Minor documentation changes
+
+## [0.2.2] - 2025-12-07
+
+- Bundler 4.0 spec fixes
+- Update dependencies
+
+## [0.2.1] - 2025-05-28
+
+- Update dependencies
+
+## [0.2.0] - 2025-01-30
+
+- It is now recommended to include `gem bundlebun` after other existing frontend-related gems in your `Gemfile`. That removes the need to install one-liner initializer monkeypatches for most cases. The gem detects and loads all integrations when loaded. Alternatively, the developer can call integration monkey-patches (`Bundlebun::Integrations::Something.bun!`) directly.
+- bundlebun now adds the bundled bun executable to `PATH`, both on Unix-like and Windows environments. This improves the support for other frontend-related libraries and gems: we don't have to monkey-patch libraries _all the time_, just when we need it.
+- While there still might be some issues, I am trying to ensure proper Windows (non-WSL) support for this gem, for a plug&play experience for Windows Ruby developers.
+- The vite-ruby integration is reworked. We don't touch the existing `bin/vite` binstub anymore. Instead, we install `bin/bun-vite` that will run Vite with Bun and use it with ruby-vite's `vite.json`. We modify the existing config file, or install a sample one.
+- The `bun:install:rails` Rake task is now `bun:install:bundling-rails`, as it only activates from `bun:install` if Cssbundling or Jsbundling are detected, does not have to do a lot with Rails itself.
+- For Windows, the gem now installs a `bin/bun.cmd` binstub, as well as `bin/bun-vite.cmd` for use with vite-ruby. If the integration was already installed, but there are no Windows binstubs in sight, run `rake bun:install` again.
+- The ExecJS test is now a proper integration test, like the other integration tests.
+- bundlebun is now properly tested on Windows (Windows Server 2025 on GitHub Actions).
+
+## [0.1.2] - 2024-12-21
+
+- Integration specs now test bundlebun + Bun against vite-ruby and cssbundling-rails + jsbundling-rails with positive real-world scenarios
+- Minor internal task changes
+- No major code changes
+
+## [0.1.1] - 2024-12-17
+
+- Switch to Yard documentation format from RDoc
+- No major code changes
+
+## [0.1.0] - 2024-12-15
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,98 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Yaroslav Markin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+Bun is licensed under the MIT License (https://github.com/oven-sh/bun/blob/main/LICENSE.md)
+
+Bun itself is MIT-licensed.
+
+## JavaScriptCore
+
+Bun statically links JavaScriptCore (and WebKit) which is LGPL-2 licensed. WebCore files from WebKit are also licensed under LGPL2. Per LGPL2:
+
+> (1) If you statically link against an LGPL’d library, you must also provide your application in an object (not necessarily source) format, so that a user has the opportunity to modify the library and relink the application.
+
+You can find the patched version of WebKit used by Bun here: <https://github.com/oven-sh/webkit>. If you would like to relink Bun with changes:
+
+- `git submodule update --init --recursive`
+- `make jsc`
+- `zig build`
+
+This compiles JavaScriptCore, compiles Bun’s `.cpp` bindings for JavaScriptCore (which are the object files using JavaScriptCore) and outputs a new `bun` binary with your changes.
+
+## Linked libraries
+
+Bun statically links these libraries:
+
+| Library | License |
+|---------|---------|
+| [`boringssl`](https://boringssl.googlesource.com/boringssl/) | [several licenses](https://boringssl.googlesource.com/boringssl/+/refs/heads/master/LICENSE) |
+| [`brotli`](https://github.com/google/brotli) | MIT |
+| [`libarchive`](https://github.com/libarchive/libarchive) | [several licenses](https://github.com/libarchive/libarchive/blob/master/COPYING) |
+| [`lol-html`](https://github.com/cloudflare/lol-html/tree/master/c-api) | BSD 3-Clause |
+| [`mimalloc`](https://github.com/microsoft/mimalloc) | MIT |
+| [`picohttp`](https://github.com/h2o/picohttpparser) | dual-licensed under the Perl License or the MIT License |
+| [`zstd`](https://github.com/facebook/zstd) | dual-licensed under the BSD License or GPLv2 license |
+| [`simdutf`](https://github.com/simdutf/simdutf) | Apache 2.0 |
+| [`tinycc`](https://github.com/tinycc/tinycc) | LGPL v2.1 |
+| [`uSockets`](https://github.com/uNetworking/uSockets) | Apache 2.0 |
+| [`zlib-cloudflare`](https://github.com/cloudflare/zlib) | zlib |
+| [`c-ares`](https://github.com/c-ares/c-ares) | MIT licensed |
+| [`libicu`](https://github.com/unicode-org/icu) 72 | [license here](https://github.com/unicode-org/icu/blob/main/icu4c/LICENSE) |
+| [`libbase64`](https://github.com/aklomp/base64/blob/master/LICENSE) | BSD 2-Clause |
+| [`libuv`](https://github.com/libuv/libuv) (on Windows) | MIT |
+| [`libdeflate`](https://github.com/ebiggers/libdeflate) | MIT |
+| A fork of [`uWebsockets`](https://github.com/jarred-sumner/uwebsockets) | Apache 2.0 licensed |
+| Parts of [Tigerbeetle's IO code](https://github.com/tigerbeetle/tigerbeetle/blob/532c8b70b9142c17e07737ab6d3da68d7500cbca/src/io/windows.zig#L1) | Apache 2.0 licensed |
+
+## Polyfills
+
+For compatibility reasons, the following packages are embedded into Bun's binary and injected if imported.
+
+| Package | License |
+|---------|---------|
+| [`assert`](https://npmjs.com/package/assert) | MIT |
+| [`browserify-zlib`](https://npmjs.com/package/browserify-zlib) | MIT |
+| [`buffer`](https://npmjs.com/package/buffer) | MIT |
+| [`constants-browserify`](https://npmjs.com/package/constants-browserify) | MIT |
+| [`crypto-browserify`](https://npmjs.com/package/crypto-browserify) | MIT |
+| [`domain-browser`](https://npmjs.com/package/domain-browser) | MIT |
+| [`events`](https://npmjs.com/package/events) | MIT |
+| [`https-browserify`](https://npmjs.com/package/https-browserify) | MIT |
+| [`os-browserify`](https://npmjs.com/package/os-browserify) | MIT |
+| [`path-browserify`](https://npmjs.com/package/path-browserify) | MIT |
+| [`process`](https://npmjs.com/package/process) | MIT |
+| [`punycode`](https://npmjs.com/package/punycode) | MIT |
+| [`querystring-es3`](https://npmjs.com/package/querystring-es3) | MIT |
+| [`stream-browserify`](https://npmjs.com/package/stream-browserify) | MIT |
+| [`stream-http`](https://npmjs.com/package/stream-http) | MIT |
+| [`string_decoder`](https://npmjs.com/package/string_decoder) | MIT |
+| [`timers-browserify`](https://npmjs.com/package/timers-browserify) | MIT |
+| [`tty-browserify`](https://npmjs.com/package/tty-browserify) | MIT |
+| [`url`](https://npmjs.com/package/url) | MIT |
+| [`util`](https://npmjs.com/package/util) | MIT |
+| [`vm-browserify`](https://npmjs.com/package/vm-browserify) | MIT |
+
+## Additional credits
+
+- Bun's JS transpiler, CSS lexer, and Node.js module resolver source code is a Zig port of [@evanw](https://github.com/evanw)’s [esbuild](https://github.com/evanw/esbuild) project.
+- Credit to [@kipply](https://github.com/kipply) for the name "Bun"!

data/README.md

@@ -0,0 +1,225 @@
+# bundlebun
+
+**bundlebun** bundles [Bun](https://bun.sh)—the all-in-one JavaScript runtime, package manager, and build tool—directly into your Ruby gem bundle. No Docker, no `curl | sh`, no Homebrew required.
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/yaroslav/bundlebun/refs/heads/main/assets/mr-bundlebun-512.png" width="256" height="256" alt="Mr. Bundlebun" title="Mr. Bundlebun">
+</div>
+
+* **Zero setup.** `bundle add bundlebun && rake bun:install` and you're done.
+* **Team-friendly.** Everyone runs the same Bun version, pinned in `Gemfile.lock`.
+* **Auto-updating.** New Bun release? bundlebun ships it automatically. Or freeze your preferred version.
+* **Integrates automatically.** Works out of the box with vite-ruby, cssbundling-rails, jsbundling-rails, and ExecJS.
+
+```sh
+bundle add bundlebun
+rake bun:install
+bin/bun --version
+```
+
+[![GitHub Release](https://img.shields.io/github/v/release/yaroslav/bundlebun)](https://github.com/yaroslav/bundlebun/releases)
+[![Docs](https://img.shields.io/badge/yard-docs-blue.svg)](https://rubydoc.info/gems/bundlebun)
+
+---
+
+## Table of Contents
+
+- [Rationale](#rationale)
+- [Install](#install)
+- [Usage](#usage)
+- [Integrations](#integrations)
+- [Versioning](#versioning)
+- [Uninstall](#uninstall)
+- [Acknowledgements](#acknowledgements)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Rationale
+
+**Modern frontend setup is needlessly complex** and may involve a lot of maintenance. Developers need _at the very least_ a JavaScript runtime (typically, Node.js), a package manager (could be npm, yarn, or pnpm), and a build tool (Vite, Webpack, esbuild, Parcel—dozens of them).
+
+- One way forward is to dockerize development environments, creating unnecessary headaches for the development team—both frontend and backend engineers (especially if the team is not that large and the project is not that complex).
+- Another approach is to declare front-ops bankruptcy and pursue the "no-build" route.
+
+**What if we could simplify this?** **Bun** is a **JavaScript runtime**, optimized for speed and developer experience. Bun is _also_ a fast JavaScript **package manager**. Bun is _also_ a **build tool**. Bun is also distributed as a single executable file.
+
+However, Bun still requires [some installation](https://bun.sh/docs/installation), and we need to make sure everyone on the team is using the same version.
+
+So, how about we just pack it into a Ruby gem as a binary and allow developers to stay updated? Then, we'll be ready every time a new Bun version is out—or the user can freeze their desired version within their Ruby project. There are no setups, large READMEs with instructions, and no enforcing the Docker workflow.
+
+**Enter bundlebun**. With a fast JavaScript runtime and a package manager included, you can even skip the build tool and use Bun itself.
+
+## Install
+
+bundlebun gem releases include a binary distribution of Bun for each supported Bun platform (macOS, Linux, Windows) and architecture. bundlebun is tested for Unix-like environments and Windows.
+
+Add bundlebun to your `Gemfile`, placing it _after_ your existing frontend-related gems:
+
+```ruby
+# Frontend-related gems go here
+# gem "vite_rails"
+
+gem "bundlebun"
+```
+
+Then run:
+
+```sh
+bundle add bundlebun
+rake bun:install
+```
+
+`rake bun:install` creates a `bin/bun` binstub and auto-detects which integrations to enable. It will also offer to migrate `package.json` scripts and `Procfile` entries to use `bin/bun`.
+
+_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)._
+
+_Windows:_ `bin\bun.cmd` is created instead. If you joined a project with only the Unix binstub, run `rake bun:install` again.
+
+## Usage
+
+### Binstub
+
+The easiest way to run Bun is via the `bin/bun` binstub:
+
+```sh
+bin/bun install
+bin/bun add postcss
+bin/bun run build
+```
+
+### PATH
+
+bundlebun prepends the bundled Bun directory to your application's `PATH`. Tools that detect a `bun` executable (like vite-ruby) find it automatically—no extra configuration needed.
+
+### Rake
+
+Alternatively, you can use a Rake task. The syntax is far from perfect—that's a limitation of Rake—but it's an option if you cannot install the binstub. Note the quotes around the parameters:
+
+```sh
+rake bun[command]  # Run bundled Bun with parameters
+```
+
+```sh
+> rake "bun[outdated]"
+bun outdated v1.1.38 (bf2f153f)
+...
+```
+
+### Ruby API
+
+```ruby
+Bundlebun.('install')               # exec: replaces the current Ruby process with Bun
+Bundlebun.call(['add', 'postcss'])  # same thing, array form
+```
+
+**Note:** `Bundlebun.call` (and the `()` shortcut) replaces the current process—it never returns. Use `Bundlebun.system` to run Bun and continue executing Ruby:
+
+```ruby
+if Bundlebun.system('install')
+  puts 'Dependencies installed!'
+end
+
+success = Bundlebun.system('test')
+# => true if Bun exited successfully, false or nil otherwise
+```
+
+See the [API documentation](https://rubydoc.info/gems/bundlebun) for full details on `Bundlebun::Runner`.
+
+### Instrumentation
+
+When ActiveSupport is available, bundlebun emits events you can subscribe to:
+
+```ruby
+ActiveSupport::Notifications.subscribe('system.bundlebun') do |event|
+  Rails.logger.info "Bun: #{event.payload[:command]} (#{event.duration.round(1)}ms)"
+end
+```
+
+Events: `system.bundlebun` (for `Bundlebun.system`) and `exec.bundlebun` (for `Bundlebun.call`). Payload: `{ command: args }`.
+
+## Integrations
+
+bundlebun auto-detects and loads integrations when you run `rake bun:install`—as long as `gem "bundlebun"` is placed _after_ the relevant gems in your `Gemfile`.
+
+### vite-ruby / vite-rails
+
+[vite-ruby](https://github.com/ElMassimo/vite_ruby) and [vite-rails](https://vite-ruby.netlify.app/) are gems that make Ruby and Rails integration with [Vite](https://vite.dev/), a great JavaScript build tool and platform, seamless and easy.
+
+The bundlebun integration is installed automatically with `rake bun:install`, or you can run it explicitly:
+
+```sh
+rake bun:install:vite
+```
+
+That will make sure you have a `bin/bun` binstub. Next, it installs a custom `bin/bun-vite` binstub to use in build scripts, and creates or updates `vite.json` to use that binstub for building. See the [Vite Ruby configuration manual](https://vite-ruby.netlify.app/config/index.html) for details on `vite.json`.
+
+To enable the integration manually:
+
+```ruby
+Bundlebun::Integrations::ViteRuby.bun!
+```
+
+### cssbundling-rails / jsbundling-rails
+
+[cssbundling-rails](https://github.com/rails/cssbundling-rails) and [jsbundling-rails](https://github.com/rails/jsbundling-rails) are Rails gems that support the traditional CSS and JS building pipeline for Ruby on Rails.
+
+Be sure to check both gems for documentation on bootstrapping your frontend build pipeline instead of duplicating approaches here. cssbundling-rails, for instance, includes an excellent sample build configuration for Bun.
+
+```sh
+# Bootstrap cssbundling-rails
+bundle add cssbundling-rails
+bin/rails css:install:[tailwind|bootstrap|bulma|postcss|sass]
+
+# Bootstrap jsbundling-rails
+bundle add jsbundling-rails
+bin/rails javascript:install:bun
+
+# Ensure bundlebun integration
+rake bun:install:bundling-rails
+```
+
+### ExecJS
+
+[ExecJS](https://github.com/rails/execjs) runs JavaScript code straight from Ruby. It supports a number of runtimes it can launch—and get a result from. Bun runtime support already exists in ExecJS; bundlebun just ensures it uses the bundled version.
+
+Works automatically when bundlebun loads after ExecJS in your `Gemfile`. To enable manually:
+
+```ruby
+Bundlebun::Integrations::ExecJS.bun!
+```
+
+## Versioning
+
+bundlebun versions follow the `#{gem.version}.#{bun.version}` scheme. For example, `0.1.0.1.1.38` = gem version `0.1.0` + Bun `1.1.38`.
+
+New gem versions are published automatically on each Bun release. Lock to a specific Bun version in your `Gemfile`, or leave it unspecified to always get the latest.
+
+## Uninstall
+
+```sh
+bundle remove bundlebun
+```
+
+Then clean up:
+
+- `bin/bun` (and `bin\bun.cmd` on Windows)
+- `bin/bun-vite` if present
+- `tasks/bundlebun.rake` if present
+- Any `bin/bun` references in scripts and configs
+- Any `Bundlebun` references in your code
+
+## Acknowledgements
+
+Bun binaries are sourced directly from [oven-sh/bun releases](https://github.com/oven-sh/bun/releases). [Bun](https://bun.sh) was created by Jarred Sumner ([@jarred-sumner](https://github.com/jarred-sumner)) and distributed under MIT.
+
+Big thanks to Jason Meller ([@terracatta](https://github.com/terracatta)) for his work on Bun's Ruby on Rails ecosystem integration—jsbundling-rails, cssbundling-rails, turbo-rails, stimulus-rails, and ExecJS support—in [this Pull Request](https://github.com/rails/rails/pull/49241).
+
+## Contributing
+
+Make sure you have up-to-date Ruby. Run `bin/setup` to install gems, install [lefthook](https://github.com/evilmartians/lefthook), and run `rake bundlebun:download` to fetch a local Bun build for tests.
+
+Run `rake rspec` to check tests. Open an issue or a PR.
+
+## License
+
+The gem is available as open source under the terms of the MIT License. See [LICENSE.txt](LICENSE.txt).

data/exe/bundlebun

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+# Install the gem first, then create a binstub.
+#
+# Add to your Gemfile:
+#
+#   gem 'bundlebun'
+#
+# Then:
+#
+#   bundle install
+#   rake bun:install
+#
+# And then:
+#
+#   bin/bun ...
+#
+# If you're looking at this file in your `bin/` directory and you're
+# no longer using bundlebun, it should be safe to delete.
+begin
+  require 'bundler/setup'
+rescue LoadError
+  # Continue without bundler if not available
+end
+require 'bundlebun'
+
+Bundlebun.call(ARGV)

data/lib/bundlebun/env_path.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # EnvPath exists to help prepend the bun binary path to the system PATH,
+  # in order to make it easier for other gems and utilities to "see" the
+  # existing bun executable without the need to monkey-patch tools that already
+  # support Bun.
+  # This approach only works when the bundlebun gem is already loaded, which
+  # is not always the case, unfortunately.
+  class EnvPath
+    class << self
+      # Returns the current system PATH.
+      #
+      # @return [String] The system PATH
+      def path
+        ENV['PATH']
+      end
+
+      # Sets the system PATH to a new value (_not_ prepends the value).
+      #
+      # @param new_path [String] The new system PATH
+      def path=(new_path)
+        ENV['PATH'] = new_path
+      end
+
+      # Prepends a new path to the system PATH.
+      # Makes sure to use different separators for different platforms.
+      #
+      # @param new_path [String] The new path to prepend
+      # @return [String] The new system PATH
+      def prepend(new_path)
+        return if new_path.nil? || new_path.empty?
+
+        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 already_present
+        path
+      end
+
+      # The `PATH` separator for the current platform (`:` or `;`)
+      #
+      # @return [String] The separator character
+      def separator
+        return @separator if defined?(@separator)
+
+        @separator = Bundlebun::Platform.windows? ? ';' : ':'
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/cssbundling.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # A Bundlebun integration for [cssbundling-rails](https://github.com/rails/cssbundling-rails).
+    #
+    # It's hard to override those methods on the fly, and a Rails initializer in the
+    # target project also does not seem to work, so we have to create a dummy task
+    # in the actual Rails project, and patch the helper module Tasks from there.
+    #
+    # When installed, makes it run a bundled Bun runtime for packing tasks.
+    #
+    # @see https://github.com/rails/cssbundling-rails
+    # @see https://github.com/rails/cssbundling-rails/blob/main/lib/tasks/cssbundling/build.rake
+    module Cssbundling
+      # Patches the existing module.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is... _not_ an initializer,
+      # but some code that can be run in a Rake task. Like a custom Rake task
+      # in `lib/tasks`.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      #
+      # @example
+      #   Bundlebun::Integrations::Cssbundling.bun!
+      def self.bun!
+        return unless defined?(::Cssbundling::Tasks)
+
+        ::Cssbundling::Tasks.prepend(self::Tasks)
+      end
+
+      # A monkeypatch for tasks that are defined in the original
+      # Rake task
+      #
+      # @see https://github.com/rails/cssbundling-rails/blob/main/lib/tasks/cssbundling/build.rake
+      module Tasks
+        extend self
+
+        def install_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} install"
+        end
+
+        def build_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} run --bun build:css"
+        end
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/execjs.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # An integration for [execjs](https://github.com/rails/execjs).
+    #
+    # Runtimes in ExecJS are declared like this: https://github.com/rails/execjs/blob/master/lib/execjs/runtimes.rb
+    # We will redefine the Bun one, changing its command.
+    #
+    # Then, we will automatically set the bundlebun-ed Bun as the default runtime.
+    #
+    # @see https://github.com/rails/execjs
+    module ExecJS
+      # Patches the existing module to use bundlebun-ed Bun in place of an
+      # already existing, spported Bun runtime: we replace it with a bundled version.
+      #
+      # Additionally, sets it as a default ExecJS runtime.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is an initializer.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      #
+      # @example
+      #   Bundlebun::Integrations::ExecJS.bun!
+      def self.bun!
+        return unless defined?(::ExecJS::Runtimes)
+
+        # Remove the existing Bun constant if it exists
+        ::ExecJS::Runtimes.send(:remove_const, :Bun) if ::ExecJS::Runtimes.const_defined?(:Bun)
+
+        # Define new Bun runtime with our custom command
+        bun_runtime = ::ExecJS::Runtimes.const_set(:Bun,
+          ::ExecJS::ExternalRuntime.new(
+            name: "Bun.sh",
+            command: [Bundlebun::Runner.binstub_or_binary_path],
+            runner_path: ::ExecJS.root + "/support/bun_runner.js",
+            encoding: "UTF-8"
+          ))
+
+        # Set the runtime
+        ::ExecJS.runtime = bun_runtime
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/jsbundling.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # A Bundlebun integration for [jsbundling-rails](https://github.com/rails/jsbundling-rails).
+    #
+    # It's hard to override those methods on the fly, and a Rails initializer in the
+    # target project also does not seem to work, so we have to create a dummy task
+    # in the actual Rails project, and patch the helper module Tasks from there.
+    #
+    # When installed, makes it run a bundled Bun runtime for packing tasks.
+    #
+    # @see https://github.com/rails/jsbundling-rails
+    # @see https://github.com/rails/jsbundling-rails/blob/main/lib/tasks/jsbundling/build.rake
+    module Jsbundling
+      # Patches the existing module.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is... not an initializer,
+      # but some code that can be run in a Rake task. Like a custom Rake task
+      # in `lib/tasks`.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      #
+      # @example
+      #   Bundlebun::Integrations::Jsbundling.bun!
+      def self.bun!
+        return unless defined?(::Jsbundling::Tasks)
+
+        ::Jsbundling::Tasks.prepend(self::Tasks)
+      end
+
+      # A monkeypatch for tasks that are defined in the original
+      # Rake task
+      #
+      # @see https://github.com/rails/jsbundling-rails/blob/main/lib/tasks/jsbundling/build.rake
+      module Tasks
+        extend self
+
+        def install_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} install"
+        end
+
+        def build_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} run --bun build"
+        end
+      end
+    end
+  end
+end