rolldown 0.1.0-x86_64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db51e0f0b374c08e6d794dfd1b38a295837ab1c390f7beea009e695545e7de50
+  data.tar.gz: fb62062954c11a87a2535e9e833d47df61da0f0dfbe5782b5ea41c3efa4b855b
+SHA512:
+  metadata.gz: 8b8217626f836279f8aa27a59bc2c5da0a73576a07d2052edc8c05e45533289292edf8d78fb9311f5d1442a06475709cffa97acdf49d29410bbf339ee599f83e
+  data.tar.gz: 1a2a2d67df8dbf872223b6b08aaca57109de5219b0f00dadbb77f51d218fba46f3980d41decaa82cb8deb4f378615d3cfbac2fd81dbdc297a12db7f4f07b62b4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Marco Roth
+
+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.

data/README.md

@@ -0,0 +1,152 @@
+<h2 align="center">⬇️ Rolldown for Ruby</h2>
+
+<h4 align="center">Blazing Fast Rust-based bundler for JavaScript.</h4>
+
+<div align="center">Ruby bindings for <a href="https://rolldown.rs">Rolldown</a>, the Rust bundler behind Vite.</div><br/>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/rolldown"><img alt="Gem Version" src="https://img.shields.io/gem/v/rolldown"></a>
+  <a href="https://rolldown.rs"><img alt="Documentation" src="https://img.shields.io/badge/rolldown.rs-documentation-green"></a>
+  <a href="https://github.com/marcoroth/rolldown-ruby/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/github/license/marcoroth/rolldown-ruby"></a>
+  <a href="https://github.com/marcoroth/rolldown-ruby/issues"><img alt="Issues" src="https://img.shields.io/github/issues/marcoroth/rolldown-ruby"></a>
+</p>
+
+<br/>
+
+### What is Rolldown for Ruby?
+
+Ruby bindings for [Rolldown](https://rolldown.rs), the Rust-based bundler for JavaScript. Bundle JavaScript from Ruby, without the need for a JavaScript runtime.
+
+Everything here is Rolldown doing the work. For what the options mean and what it can do, [rolldown.rs](https://rolldown.rs) is the reference.
+
+### Installation
+
+```bash
+bundle add rolldown
+```
+
+Anywhere a precompiled gem is not published, the gem builds from source and needs the [Rust toolchain](https://rustup.rs) at 1.96 or newer.
+
+### Usage
+
+The options follow [Rolldown's JavaScript API](https://rolldown.rs/reference/config-options), so a `rolldown.config.js` ports across as it reads.
+
+```ruby
+result = Rolldown.build(
+  input: "src/main.js",
+  output: {
+    file: "bundle.js"
+  }
+)
+
+result.entry.code
+```
+
+Everything comes back in memory. `write` puts it on disk, chunks and source maps together, creating the directory if it is missing.
+
+```ruby
+result = Rolldown.build(
+  input: "app/javascript/application.js",
+  output: {
+    dir: "app/assets/builds",
+    format: "esm",
+    sourcemap: true,
+    minify: true
+  }
+)
+
+result.write
+#=> ["app/assets/builds/application.js", "app/assets/builds/application.js.map"]
+```
+
+`write` goes to `output.dir`, or to whatever directory `output.file` names, and takes an argument to go somewhere else. `output.dir` also decides what the source map's relative paths look like, so it is worth setting even when writing elsewhere.
+
+Writing happens in Ruby. Rolldown can do it, but it hands the whole bundle back either way, so writing from Rust measured slower while giving the caller less say over where files land.
+
+#### Entry points
+
+An entry point is a string, a list, or a hash of names, matching `string | string[] | Record<string, string>`.
+
+```ruby
+Rolldown.build(input: "src/main.js")
+Rolldown.build(input: ["src/main.js", "src/admin.js"])
+Rolldown.build(input: { app: "src/main.js", admin: "src/admin.js" })
+```
+
+#### Bundling something that is not a file
+
+`modules` hands the bundler sources it holds in memory, keyed by whatever name you want to import them under.
+
+```ruby
+Rolldown.build(
+  input: "app:entry",
+  modules: {
+    "app:entry" => %(import { card } from "app:users/card"\ncard()),
+    "app:users/card" => %(export function card() { ... })
+  }
+)
+```
+
+They mix freely with what is on disk. A module in memory can import an npm package or a relative file, and a file on disk can import a module in memory. A relative import out of a module in memory resolves against that module's own name, so give it a path-shaped one when it needs to reach real files next to it.
+
+This exists so a generator can transform sources in Ruby first and bundle the result without writing anything out. There are no plugins, and no Ruby runs while the bundle does.
+
+#### What comes back
+
+```ruby
+result.chunks    # every chunk, each with filename, name, code, map, imports, exports and module_ids
+result.assets    # source maps and anything else emitted alongside
+result.entry     # the first chunk that is an entry point
+result.warnings  # diagnostics that did not stop the build
+result.errors    # diagnostics that did
+result.failed?
+```
+
+A build that produces nothing usable raises `Rolldown::BuildError` carrying what went wrong. Pass `strict: true` to raise on warnings too.
+
+#### Bundling, not installing
+
+Bare imports resolve with no plugin and no configuration whenever the files are on disk. Putting them there is a package manager, and this gem is not one. An app whose JavaScript is its own code plus a few vendored libraries needs nothing else.
+
+#### Which options are bound
+
+Of the JavaScript API's 22 input options and 49 output options, these are bound so far.
+
+At the top level, `input`, `cwd`, `external`, `platform`, `treeshake`, `shim_missing_exports`, `module_types` and `modules`, plus `transform` for `define`.
+
+Under `output`, `dir`, `file`, `format`, `name`, `exports`, `sourcemap`, `minify`, `banner`, `footer`, `intro`, `outro`, `entry_file_names`, `chunk_file_names`, `asset_file_names`, `keep_names`, `legal_comments` and `es_module`.
+
+Names follow the JavaScript spelling in snake_case, so `entryFileNames` is `entry_file_names`. Where JavaScript and Rust disagree, JavaScript wins, and `define` sits under `transform` for the same reason.
+
+#### What cannot cross
+
+Options that take a JavaScript function in the JavaScript API have nowhere to go in Ruby. `plugins`, `on_log`, `manual_chunks` and `sourcemap_path_transform` are refused by name, and anything else Rolldown does not recognise is refused too.
+
+Watch mode, hot module replacement and the dev server are not bound.
+
+### Development
+
+The gem is a C extension over a Rust crate. `rust/` builds a static library and generates the C header with [cbindgen](https://github.com/mozilla/cbindgen), `ext/rolldown/` wraps it, and `lib/` is the Ruby API over that.
+
+```bash
+bin/setup
+bundle exec rake
+```
+
+`sig/` is generated from the `#:` annotations next to the code. Regenerate it with `rake rbs` after changing a signature, and CI checks that it matches.
+
+### Acknowledgements
+
+[Rolldown](https://rolldown.rs) is maintained at [rolldown/rolldown](https://github.com/rolldown/rolldown) and is part of [VoidZero](https://voidzero.dev)'s toolchain for JavaScript. This gem only calls into it. Thank you for building these tools!
+
+### Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcoroth/rolldown-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/marcoroth/rolldown-ruby/blob/main/CODE_OF_CONDUCT.md).
+
+Issues with parsing, transforming or minifying itself belong [upstream](https://github.com/rolldown/rolldown/issues), since this gem does none of that. Issues with the Ruby API, the build, or the bindings belong here.
+
+### License
+
+The Ruby, C, and Rust code in this gem is available under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+It builds against [Rolldown](https://github.com/rolldown/rolldown), which is MIT licensed and carries some MIT code of its own. A copy of both travels with the gem in [`licenses/`](licenses).

data/ext/rolldown/extconf.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "fileutils"
+
+ext_dir = __dir__
+root_dir = File.expand_path("../..", ext_dir)
+
+rust_dir = File.join(root_dir, "rust")
+
+unless File.exist?(File.join(rust_dir, "Cargo.toml"))
+  abort <<~MESSAGE
+
+    ERROR: Rust sources not found at #{rust_dir}.
+
+  MESSAGE
+end
+
+unless system("cargo --version > /dev/null 2>&1")
+  abort <<~MESSAGE
+
+    ERROR: Rust toolchain not found.
+
+    rolldown requires the Rust toolchain to compile from source.
+
+    Install Rust: https://rustup.rs
+
+  MESSAGE
+end
+
+RUST_TARGETS = {
+  "aarch64-linux-gnu" => "aarch64-unknown-linux-gnu",
+  "aarch64-linux-musl" => "aarch64-unknown-linux-musl",
+  "arm-linux-gnu" => "armv7-unknown-linux-gnueabihf",
+  "arm-linux-musl" => "armv7-unknown-linux-musleabihf",
+  "arm64-darwin" => "aarch64-apple-darwin",
+  "x86_64-darwin" => "x86_64-apple-darwin",
+  "x86_64-linux-gnu" => "x86_64-unknown-linux-gnu",
+  "x86_64-linux-musl" => "x86_64-unknown-linux-musl",
+  "x86-linux-gnu" => "i686-unknown-linux-gnu",
+  "x86-linux-musl" => "i686-unknown-linux-musl",
+}.freeze
+
+cross_compiling = ENV.key?("RUBY_CC_VERSION")
+target_platform = ENV.fetch("CARGO_BUILD_TARGET", nil)
+
+if cross_compiling && target_platform.nil?
+  rcd_platform = ENV.fetch("RCD_PLATFORM", "")
+  target_platform = RUST_TARGETS[rcd_platform]
+
+  if target_platform.nil?
+    ruby_platform = RbConfig::CONFIG["arch"]
+    target_platform = RUST_TARGETS.values.find { |target| ruby_platform.include?(target.split("-").first) }
+  end
+end
+
+header_path = File.join(ext_dir, "include", "rolldown.h")
+
+FileUtils.mkdir_p(File.dirname(header_path))
+
+target_dir = File.join(rust_dir, "target")
+
+if target_platform
+  puts "rolldown: Cross-compiling Rust for target: #{target_platform}"
+
+  system("rustup target add #{target_platform}") || warn("rolldown: Failed to add Rust target #{target_platform}")
+
+  cargo_args = "--release --locked --target #{target_platform}"
+  lib_dir = File.join(target_dir, target_platform, "release")
+else
+  puts "rolldown: Compiling Rust library for native platform..."
+
+  cargo_args = "--release --locked"
+  lib_dir = File.join(target_dir, "release")
+end
+
+unless system("cd #{rust_dir} && cargo build #{cargo_args}")
+  abort "ERROR: Failed to compile rolldown from Rust source."
+end
+
+unless File.exist?(header_path)
+  abort "ERROR: cbindgen did not generate #{header_path}. Try `cargo clean` in #{rust_dir} and reinstall."
+end
+
+static_lib = File.join(lib_dir, "librolldown_ffi.a")
+
+developing = File.exist?(File.join(root_dir, ".git"))
+
+if File.exist?(static_lib) && !developing
+  vendored = File.join(ext_dir, "librolldown_ffi.a")
+
+  FileUtils.cp(static_lib, vendored)
+  FileUtils.rm_rf(target_dir)
+
+  puts "rolldown: Static library vendored at #{vendored}, Rust build directory removed"
+
+  $LDFLAGS << " #{vendored}"
+elsif File.exist?(static_lib)
+  puts "rolldown: Static library found at #{static_lib}"
+
+  $LDFLAGS << " #{static_lib}"
+else
+  host_os = target_platform || RbConfig::CONFIG["host_os"]
+
+  lib_name = case host_os
+             when /darwin/ then "librolldown_ffi.dylib"
+             when /mingw|mswin|windows/ then "rolldown_ffi.dll"
+             else "librolldown_ffi.so"
+             end
+
+  lib_path = File.join(lib_dir, lib_name)
+
+  abort "ERROR: Shared library not found at #{lib_path}" unless File.exist?(lib_path)
+
+  puts "rolldown: Shared library found at #{lib_path} (dynamic)"
+
+  $LDFLAGS << " -L#{lib_dir} -lrolldown_ffi"
+  $LDFLAGS << " -Wl,-rpath,#{lib_dir}" if RbConfig::CONFIG["host_os"].match?(/darwin|linux/)
+end
+
+$CFLAGS << " -I#{ext_dir}"
+
+create_makefile("rolldown/rolldown")

data/ext/rolldown/include/rolldown.h

@@ -0,0 +1,54 @@
+/* Generated by cbindgen, do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef ROLLDOWN_H
+#define ROLLDOWN_H
+
+typedef enum RolldownErrorCode {
+  ROLLDOWN_ERROR_CODE_NONE = 0,
+  ROLLDOWN_ERROR_CODE_OPTION,
+  ROLLDOWN_ERROR_CODE_ENCODING,
+  ROLLDOWN_ERROR_CODE_BUILD,
+  ROLLDOWN_ERROR_CODE_IO,
+  ROLLDOWN_ERROR_CODE_INTERNAL,
+  ROLLDOWN_ERROR_CODE_PANIC,
+} RolldownErrorCode;
+
+typedef struct RolldownResult {
+  char *value;
+  uintptr_t value_len;
+  char *error;
+  enum RolldownErrorCode code;
+} RolldownResult;
+
+/**
+ * # Safety
+ *
+ * `options_json` must be a valid, nul-terminated UTF-8 string.
+ */
+struct RolldownResult rolldown_build(const char *options_json);
+
+char *rolldown_version(void);
+
+char *rolldown_rolldown_version(void);
+
+/**
+ * # Safety
+ *
+ * `value` must be a pointer this library returned, and must not be used afterwards.
+ */
+void rolldown_string_free(char *value);
+
+/**
+ * # Safety
+ *
+ * `result` must be one this library returned, and must not be used afterwards.
+ */
+void rolldown_result_free(struct RolldownResult result);
+
+struct RolldownResult rolldown_panic_for_test(void);
+
+#endif  /* ROLLDOWN_H */

data/ext/rolldown/rolldown.c

@@ -0,0 +1,130 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+#include "include/rolldown.h"
+
+static VALUE rb_mRolldown;
+static VALUE rb_mBackend;
+static VALUE rb_eError;
+static VALUE rb_eOptionError;
+static VALUE rb_eRolldownEncodingError;
+static VALUE rb_eBuildError;
+static VALUE rb_eRolldownIOError;
+static VALUE rb_eInternalError;
+static VALUE rb_ePanicError;
+
+typedef struct RolldownResult (*rolldown_function)(const char *);
+
+struct call_arguments {
+  rolldown_function function;
+  const char *options;
+  struct RolldownResult result;
+};
+
+static VALUE make_utf8_string(const char *cstring) {
+  return rb_enc_str_new_cstr(cstring, rb_utf8_encoding());
+}
+
+static VALUE take_utf8_string(char *cstring) {
+  if (!cstring) return Qnil;
+
+  VALUE string = make_utf8_string(cstring);
+  rolldown_string_free(cstring);
+
+  return string;
+}
+
+static VALUE error_class_for(enum RolldownErrorCode code) {
+  switch (code) {
+    case ROLLDOWN_ERROR_CODE_OPTION: return rb_eOptionError;
+    case ROLLDOWN_ERROR_CODE_ENCODING: return rb_eRolldownEncodingError;
+    case ROLLDOWN_ERROR_CODE_BUILD: return rb_eBuildError;
+    case ROLLDOWN_ERROR_CODE_IO: return rb_eRolldownIOError;
+    case ROLLDOWN_ERROR_CODE_PANIC: return rb_ePanicError;
+    default: return rb_eInternalError;
+  }
+}
+
+static VALUE unwrap(struct RolldownResult result) {
+  if (result.error) {
+    VALUE message = make_utf8_string(result.error);
+    VALUE error_class = error_class_for(result.code);
+
+    rolldown_result_free(result);
+
+    rb_raise(error_class, "%s", StringValueCStr(message));
+  }
+
+  if (!result.value) {
+    rolldown_result_free(result);
+
+    rb_raise(rb_eInternalError, "rolldown returned no result");
+  }
+
+  VALUE value = rb_enc_str_new(result.value, (long) result.value_len, rb_utf8_encoding());
+
+  rolldown_result_free(result);
+
+  return value;
+}
+
+static void *without_gvl(void *data) {
+  struct call_arguments *arguments = (struct call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->options);
+
+  return NULL;
+}
+
+static VALUE call(rolldown_function function, VALUE options) {
+  struct call_arguments arguments;
+
+  arguments.function = function;
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(without_gvl, &arguments, NULL, NULL);
+
+  return unwrap(arguments.result);
+}
+
+static VALUE rb_build(VALUE self, VALUE options) {
+  (void) self;
+
+  return call(rolldown_build, options);
+}
+
+static VALUE rb_panic_for_test(VALUE self) {
+  (void) self;
+
+  return unwrap(rolldown_panic_for_test());
+}
+
+static VALUE rb_native_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(rolldown_version());
+}
+
+static VALUE rb_rolldown_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(rolldown_rolldown_version());
+}
+
+void Init_rolldown(void) {
+  rb_mRolldown = rb_define_module("Rolldown");
+  rb_mBackend = rb_define_module_under(rb_mRolldown, "Backend");
+
+  rb_eError = rb_define_class_under(rb_mRolldown, "Error", rb_eStandardError);
+  rb_eOptionError = rb_define_class_under(rb_mRolldown, "OptionError", rb_eError);
+  rb_eRolldownEncodingError = rb_define_class_under(rb_mRolldown, "EncodingError", rb_eError);
+  rb_eBuildError = rb_define_class_under(rb_mRolldown, "BuildError", rb_eError);
+  rb_eRolldownIOError = rb_define_class_under(rb_mRolldown, "IOError", rb_eError);
+  rb_eInternalError = rb_define_class_under(rb_mRolldown, "InternalError", rb_eError);
+  rb_ePanicError = rb_define_class_under(rb_mRolldown, "PanicError", rb_eInternalError);
+
+  rb_define_singleton_method(rb_mBackend, "build", rb_build, 1);
+  rb_define_singleton_method(rb_mBackend, "panic_for_test", rb_panic_for_test, 0);
+  rb_define_singleton_method(rb_mBackend, "version", rb_native_version, 0);
+  rb_define_singleton_method(rb_mBackend, "rolldown_version", rb_rolldown_version, 0);
+}

data/lib/rolldown/asset.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rolldown
+  class Asset
+    attr_reader :filename #: String
+    attr_reader :names #: Array[String]
+    attr_reader :source #: String?
+
+    #: (Hash[String, untyped]) -> Rolldown::Asset
+    def self.from_hash(hash)
+      new(filename: hash.fetch("filename"), names: hash.fetch("names"), source: hash["source"])
+    end
+
+    #: (filename: String, names: Array[String], source: String?) -> void
+    def initialize(filename:, names:, source:)
+      @filename = filename.freeze
+      @names = names.freeze
+      @source = source&.freeze
+
+      freeze
+    end
+
+    #: () -> String
+    def to_s
+      source.to_s
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{filename.inspect}#{" #{source.bytesize} bytes" if source}>"
+    end
+  end
+end

data/lib/rolldown/backend.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rolldown
+  module Backend
+    module Unavailable
+      #: (String) -> String
+      def build(_options_json)
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def panic_for_test
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def version
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def rolldown_version
+        unavailable(__method__)
+      end
+
+      private
+
+      #: (Symbol?) -> bot
+      def unavailable(name)
+        raise NotImplementedError, "Rolldown::Backend.#{name} is defined by the native extension, which did not load"
+      end
+    end
+
+    extend Unavailable
+  end
+end

data/lib/rolldown/build_result.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "fileutils"
+
+module Rolldown
+  class BuildResult
+    attr_reader :chunks #: Array[Rolldown::Chunk]
+    attr_reader :assets #: Array[Rolldown::Asset]
+    attr_reader :warnings #: Array[Rolldown::Diagnostic]
+    attr_reader :errors #: Array[Rolldown::Diagnostic]
+    attr_reader :dir #: String?
+    attr_reader :cwd #: String?
+
+    #: (String, ?String?, ?String?) -> Rolldown::BuildResult
+    def self.from_json(payload, dir = nil, cwd = nil)
+      parsed = JSON.parse(payload)
+
+      new(
+        dir: dir,
+        cwd: cwd,
+        chunks: parsed.fetch("chunks").map { |chunk| Chunk.from_hash(chunk) },
+        assets: parsed.fetch("assets").map { |asset| Asset.from_hash(asset) },
+        warnings: parsed.fetch("warnings").map { |warning| Diagnostic.from_hash(warning) },
+        errors: parsed.fetch("errors").map { |error| Diagnostic.from_hash(error) },
+        failed: parsed.fetch("failed")
+      )
+    end #: String?
+
+    #: (chunks: Array[Rolldown::Chunk], assets: Array[Rolldown::Asset], warnings: Array[Rolldown::Diagnostic], errors: Array[Rolldown::Diagnostic], failed: bool, ?dir: String?, ?cwd: String?) -> void
+    def initialize(chunks:, assets:, warnings:, errors:, failed:, dir: nil, cwd: nil)
+      @dir = dir
+      @cwd = cwd
+      @chunks = chunks.freeze
+      @assets = assets.freeze
+      @warnings = warnings.freeze
+      @errors = errors.freeze
+      @failed = failed
+
+      freeze
+    end
+
+    #: () -> bool
+    def failed?
+      @failed
+    end
+
+    #: () -> bool
+    def errors?
+      !errors.empty?
+    end
+
+    #: () -> bool
+    def warnings?
+      !warnings.empty?
+    end
+
+    #: (?String?) -> Array[String]
+    def write(into = dir)
+      raise IOError, "no directory to write to, pass one or set output.dir or output.file" unless into
+
+      root = cwd ? File.expand_path(into, cwd) : into
+
+      FileUtils.mkdir_p(root)
+
+      (chunks + assets).map do |file|
+        path = Pathname.new(root).join(file.filename).cleanpath.to_s
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, file.to_s)
+
+        path
+      end
+    end
+
+    #: () -> Rolldown::Chunk?
+    def entry
+      chunks.find(&:entry?)
+    end
+
+    #: (?strict: bool) -> Rolldown::BuildResult
+    def validate!(strict: false)
+      raise BuildError, errors.map(&:message).join("\n\n") if failed? || errors?
+      raise BuildError, warnings.map(&:message).join("\n\n") if strict && warnings?
+
+      self
+    end
+
+    #: () -> String
+    def to_s
+      chunks.map(&:code).join("\n")
+    end
+
+    #: () -> String
+    def inspect
+      parts = ["chunks=#{chunks.length}"]
+      parts << "assets=#{assets.length}" unless assets.empty?
+      parts << "warnings=#{warnings.length}" unless warnings.empty?
+      parts << "errors=#{errors.length}" unless errors.empty?
+      parts << "failed" if failed?
+
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+  end
+end