rolldown 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28f0f4512b0121ad746f54c1df63f3e4f94a2f96136f347dc9ceebe9f0ede04d
-  data.tar.gz: 9e437fefb81181be710087a7f9432eccd558fcc2b1145030a58612b03130147c
+  metadata.gz: 48484d046263b114fc8c2c6cdcaaaa1bc85511f6d8ccc1de6b8dc9a12303e3a6
+  data.tar.gz: ed41d171fb77c02c67e469281d3dfaa6c6819a11841a38123ced8461a4cf487d
 SHA512:
-  metadata.gz: 4c7a4aa427585fd0674547a2c91993c8023c5292b26ca1d19794f1529ccaf7b45c6b09d5d7046f64271a988fcc775d2fcc5b0f9901a241ad0b16f41c17f33d26
-  data.tar.gz: 10cfc4fc8876b6e6ea42edfbf8325cddcaf44443835517c5ff2d329e3d799eff65517d5b3fc2d47790e7711ac1c970effe5c402bdf5b25e858285010666bd964
+  metadata.gz: 80879741fe1dd7925e19c09e1abaaa7986248fef49a35eefffabd2d621b0ed8b5d4708d2af45c9d97ec9ad339a902ef00bedb77d38549b974c194b237c0b65e5
+  data.tar.gz: cc5fce1e3dba470a61762372a58fcf3cc8c0f6b9b39a8f2c98322da92f37575a6142745c128a135567f1fd6947a0bd6fd3607aed95a38fc70144f532f3ecdd6e

data/README.md

@@ -1,8 +1,8 @@
-<h2 align="center">Rolldown for Ruby</h2>
+<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-based bundler for JavaScript.</div><br/>
+<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>
@@ -29,7 +29,100 @@ Anywhere a precompiled gem is not published, the gem builds from source and need
 
 ### Usage
 
-TODO
+The options follow [Rolldown's JavaScript API](https://rolldown.rs/reference/), 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
 
@@ -56,4 +149,4 @@ Issues with parsing, transforming or minifying itself belong [upstream](https://
 
 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.
+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

data/lib/rolldown/chunk.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Rolldown
+  class Chunk
+    attr_reader :filename #: String
+    attr_reader :name #: String
+    attr_reader :code #: String
+    attr_reader :map #: String?
+    attr_reader :imports #: Array[String]
+    attr_reader :dynamic_imports #: Array[String]
+    attr_reader :exports #: Array[String]
+    attr_reader :module_ids #: Array[String]
+
+    #: (Hash[String, untyped]) -> Rolldown::Chunk
+    def self.from_hash(hash)
+      new(
+        filename: hash.fetch("filename"),
+        name: hash.fetch("name"),
+        code: hash.fetch("code"),
+        map: hash["map"],
+        entry: hash.fetch("is_entry"),
+        dynamic_entry: hash.fetch("is_dynamic_entry"),
+        imports: hash.fetch("imports"),
+        dynamic_imports: hash.fetch("dynamic_imports"),
+        exports: hash.fetch("exports"),
+        module_ids: hash.fetch("module_ids")
+      )
+    end
+
+    #: (filename: String, name: String, code: String, map: String?, entry: bool, dynamic_entry: bool, imports: Array[String], dynamic_imports: Array[String], exports: Array[String], module_ids: Array[String]) -> void
+    def initialize(filename:, name:, code:, map:, entry:, dynamic_entry:, imports:, dynamic_imports:, exports:, module_ids:)
+      @filename = filename.freeze
+      @name = name.freeze
+      @code = code.freeze
+      @map = map&.freeze
+      @entry = entry
+      @dynamic_entry = dynamic_entry
+      @imports = imports.freeze
+      @dynamic_imports = dynamic_imports.freeze
+      @exports = exports.freeze
+      @module_ids = module_ids.freeze
+
+      freeze
+    end
+
+    #: () -> bool
+    def entry?
+      @entry
+    end
+
+    #: () -> bool
+    def dynamic_entry?
+      @dynamic_entry
+    end
+
+    #: () -> String
+    def to_s
+      code
+    end
+
+    #: () -> String
+    def inspect
+      parts = [filename.inspect, "#{code.bytesize} bytes"]
+      parts << "entry" if entry?
+      parts << "map" if map
+
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+  end
+end