rbxx 0.1.0

data/single_include/rbxx/rbxx.hpp

@@ -0,0 +1,3211 @@
+// Generated by scripts/amalgamate.rb. Do not edit directly.
+#pragma once
+
+// BEGIN rbxx/detail/ruby_include.hpp
+
+#if defined(_MSC_VER)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#pragma warning(push)
+#pragma warning(disable : 4127 4244 4267 4996)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/version.h>
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+#define RBXX_RUBY_VERSION_MAJOR RUBY_API_VERSION_MAJOR
+#define RBXX_RUBY_VERSION_MINOR RUBY_API_VERSION_MINOR
+#define RBXX_RUBY_VERSION_TEENY RUBY_API_VERSION_TEENY
+
+#if RUBY_API_VERSION_MAJOR < 4
+// CRuby exports this debug helper before 4.0 but does not declare it in ruby/thread.h.
+extern "C" int ruby_thread_has_gvl_p(void);
+#endif
+
+static_assert(RUBY_API_VERSION_MAJOR >= 3, "rbxx requires CRuby 3.1 or newer");
+// END rbxx/detail/ruby_include.hpp
+
+// BEGIN rbxx/value.hpp
+
+
+#include <type_traits>
+
+namespace rbxx {
+
+/// @brief A zero-overhead, non-owning view of a Ruby VALUE.
+/// @code rbxx::value nil{Qnil}; @endcode
+class value {
+public:
+  /// @brief Constructs a nil value.
+  constexpr value() noexcept = default;
+
+  /// @brief Wraps a raw Ruby VALUE without pinning it.
+  /// @code auto wrapped = rbxx::value{Qtrue}; @endcode
+  explicit constexpr value(VALUE raw) noexcept : raw_(raw) {}
+
+  /// @brief Returns the wrapped Ruby VALUE.
+  /// @code VALUE raw = wrapped.raw(); @endcode
+  [[nodiscard]] constexpr VALUE raw() const noexcept { return raw_; }
+
+  /// @brief Returns whether this value is nil.
+  /// @code if (wrapped.is_nil()) { return; } @endcode
+  [[nodiscard]] constexpr bool is_nil() const noexcept { return NIL_P(raw_); }
+
+  /// @brief Returns whether this value is a Ruby boolean.
+  [[nodiscard]] constexpr bool is_bool() const noexcept { return raw_ == Qtrue || raw_ == Qfalse; }
+
+  /// @brief Returns whether this value is a Ruby Integer.
+  [[nodiscard]] bool is_integer() const noexcept { return RB_INTEGER_TYPE_P(raw_); }
+
+  /// @brief Returns whether this value is a Ruby Float.
+  [[nodiscard]] bool is_float() const noexcept { return RB_TYPE_P(raw_, T_FLOAT); }
+
+  /// @brief Returns whether this value is a Ruby String.
+  [[nodiscard]] bool is_string() const noexcept { return RB_TYPE_P(raw_, T_STRING); }
+
+  /// @brief Returns whether this value is a Ruby Symbol.
+  [[nodiscard]] bool is_symbol() const noexcept { return SYMBOL_P(raw_); }
+
+  /// @brief Returns whether this value is a Ruby Array.
+  [[nodiscard]] bool is_array() const noexcept { return RB_TYPE_P(raw_, T_ARRAY); }
+
+  /// @brief Returns whether this value is a Ruby Hash.
+  [[nodiscard]] bool is_hash() const noexcept { return RB_TYPE_P(raw_, T_HASH); }
+
+private:
+  VALUE raw_ = Qnil;
+};
+
+static_assert(std::is_trivially_copyable_v<value>);
+static_assert(sizeof(value) == sizeof(VALUE));
+
+/// @brief Keeps a temporary Ruby value visible to the conservative GC.
+/// @code rbxx::gc_guard(value); @endcode
+inline void gc_guard(value guarded) noexcept {
+  VALUE raw = guarded.raw();
+  RB_GC_GUARD(raw);
+}
+
+} // namespace rbxx
+// END rbxx/value.hpp
+
+// BEGIN rbxx/object.hpp
+
+
+#include <memory>
+#include <utility>
+
+namespace rbxx {
+namespace detail {
+
+class object_cell {
+public:
+  explicit object_cell(VALUE initial) noexcept : stored_(initial) {
+    rb_gc_register_address(&stored_);
+  }
+
+  object_cell(const object_cell&) = delete;
+  object_cell& operator=(const object_cell&) = delete;
+
+  ~object_cell() noexcept { rb_gc_unregister_address(&stored_); }
+
+  [[nodiscard]] VALUE raw() const noexcept { return stored_; }
+
+private:
+  VALUE stored_;
+};
+
+} // namespace detail
+
+/// @brief A copyable, movable RAII handle that pins a Ruby object across GC and compaction.
+/// @code rbxx::object pinned{rbxx::value{ruby_value}}; @endcode
+class object {
+public:
+  /// @brief Constructs an empty handle representing nil.
+  object() noexcept = default;
+
+  /// @brief Pins the supplied Ruby value.
+  /// @code rbxx::object pinned{rbxx::value{Qtrue}}; @endcode
+  explicit object(value initial) : cell_(std::make_shared<detail::object_cell>(initial.raw())) {}
+
+  /// @brief Pins the supplied raw Ruby VALUE.
+  explicit object(VALUE initial) : object(value{initial}) {}
+
+  object(const object&) noexcept = default;
+  object(object&&) noexcept = default;
+  object& operator=(const object&) noexcept = default;
+  object& operator=(object&&) noexcept = default;
+  ~object() = default;
+
+  /// @brief Returns the pinned object as a non-owning value view.
+  /// @code rbxx::value current = pinned.get(); @endcode
+  [[nodiscard]] value get() const noexcept { return value{raw()}; }
+
+  /// @brief Returns the current raw VALUE, updated after compaction.
+  [[nodiscard]] VALUE raw() const noexcept { return cell_ ? cell_->raw() : Qnil; }
+
+  /// @brief Returns whether the handle is empty or pins nil.
+  [[nodiscard]] bool is_nil() const noexcept { return NIL_P(raw()); }
+
+  /// @brief Releases this handle's ownership of the pin.
+  /// @code pinned.reset(); @endcode
+  void reset() noexcept { cell_.reset(); }
+
+private:
+  std::shared_ptr<detail::object_cell> cell_;
+};
+
+} // namespace rbxx
+// END rbxx/object.hpp
+
+// BEGIN rbxx/exception.hpp
+
+
+#include <exception>
+#include <new>
+#include <stdexcept>
+#include <string>
+
+namespace rbxx {
+
+/// @brief A C++ exception that preserves the original Ruby exception object.
+/// @code catch (const rbxx::ruby_error& error) { error.reraise(); } @endcode
+class ruby_error : public std::exception {
+public:
+  /// @brief Pins a Ruby exception for propagation through C++ frames.
+  explicit ruby_error(value exception) : exception_(exception) {}
+  explicit ruby_error(VALUE exception) : exception_(exception) {}
+
+  /// @brief Returns a stable description for C++ diagnostics.
+  [[nodiscard]] const char* what() const noexcept override { return "Ruby exception"; }
+
+  /// @brief Returns the preserved Ruby exception.
+  [[nodiscard]] value exception() const noexcept { return exception_.get(); }
+
+  /// @brief Returns the Ruby exception class name.
+  [[nodiscard]] std::string ruby_class_name() const;
+
+  /// @brief Returns the Ruby exception message.
+  [[nodiscard]] std::string message() const;
+
+  /// @brief Throws a copy so the outer Ruby boundary can transparently re-raise it.
+  [[noreturn]] void reraise() const { throw *this; }
+
+private:
+  object exception_;
+};
+
+namespace detail {
+
+inline VALUE exception_class_name(VALUE exception) { return rb_class_name(CLASS_OF(exception)); }
+
+inline VALUE exception_message(VALUE exception) {
+  VALUE message = rb_funcall(exception, rb_intern("message"), 0);
+  return rb_obj_as_string(message);
+}
+
+inline std::string protected_exception_string(VALUE exception, VALUE (*function)(VALUE)) {
+  int state = 0;
+  VALUE string = rb_protect(function, exception, &state);
+  if (state != 0) {
+    VALUE nested = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    throw ruby_error(nested);
+  }
+  return std::string(RSTRING_PTR(string), static_cast<std::size_t>(RSTRING_LEN(string)));
+}
+
+struct exception_creation {
+  VALUE klass;
+  const char* message;
+};
+
+inline VALUE create_exception(VALUE opaque) {
+  auto* creation = reinterpret_cast<exception_creation*>(opaque);
+  return rb_exc_new_cstr(creation->klass, creation->message);
+}
+
+inline VALUE make_exception(VALUE klass, const char* message) noexcept {
+  exception_creation creation{klass, message};
+  int state = 0;
+  VALUE result = rb_protect(create_exception, reinterpret_cast<VALUE>(&creation), &state);
+  if (state == 0) {
+    return result;
+  }
+
+  result = rb_errinfo();
+  rb_set_errinfo(Qnil);
+  return result;
+}
+
+/// @brief Converts the active C++ exception into a Ruby exception VALUE without raising it.
+/// @code catch (...) { pending = rbxx::detail::translate_current_exception(); } @endcode
+inline VALUE translate_current_exception() noexcept {
+  try {
+    throw;
+  } catch (const ruby_error& error) {
+    return error.exception().raw();
+  } catch (const std::invalid_argument& error) {
+    return make_exception(rb_eArgError, error.what());
+  } catch (const std::out_of_range& error) {
+    return make_exception(rb_eRangeError, error.what());
+  } catch (const std::range_error& error) {
+    return make_exception(rb_eRangeError, error.what());
+  } catch (const std::bad_alloc& error) {
+    return make_exception(rb_eNoMemError, error.what());
+  } catch (const std::domain_error& error) {
+    return make_exception(rb_eMathDomainError, error.what());
+  } catch (const std::exception& error) {
+    return make_exception(rb_eRuntimeError, error.what());
+  } catch (...) {
+    return make_exception(rb_eRuntimeError, "unknown C++ exception");
+  }
+}
+
+} // namespace detail
+
+inline std::string ruby_error::ruby_class_name() const {
+  return detail::protected_exception_string(exception_.raw(), detail::exception_class_name);
+}
+
+inline std::string ruby_error::message() const {
+  return detail::protected_exception_string(exception_.raw(), detail::exception_message);
+}
+
+} // namespace rbxx
+// END rbxx/exception.hpp
+
+// BEGIN rbxx/protect.hpp
+
+
+#include <exception>
+#include <functional>
+#include <optional>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+namespace detail {
+
+template <typename Function, typename... Args> struct protect_payload {
+  using function_type = std::decay_t<Function>;
+  using result_type = std::invoke_result_t<function_type&, std::decay_t<Args>&...>;
+  using stored_result = std::conditional_t<std::is_void_v<result_type>, bool, result_type>;
+
+  function_type function;
+  std::tuple<std::decay_t<Args>...> args;
+  std::optional<stored_result> result;
+  std::exception_ptr cpp_exception;
+};
+
+template <typename Payload> VALUE protect_trampoline(VALUE opaque) noexcept {
+  auto* payload = reinterpret_cast<Payload*>(opaque);
+  try {
+    if constexpr (std::is_void_v<typename Payload::result_type>) {
+      std::apply(payload->function, payload->args);
+      payload->result.emplace(true);
+    } else {
+      payload->result.emplace(std::apply(payload->function, payload->args));
+    }
+  } catch (...) {
+    payload->cpp_exception = std::current_exception();
+  }
+  return Qnil;
+}
+
+} // namespace detail
+
+/// @brief Invokes a Ruby C API operation through rb_protect and converts longjmp to ruby_error.
+/// @code VALUE string = rbxx::protect(rb_utf8_str_new_cstr, "safe"); @endcode
+template <typename Function, typename... Args> auto protect(Function&& function, Args&&... args) {
+  using payload_type = detail::protect_payload<Function, Args...>;
+  static_assert(!std::is_reference_v<typename payload_type::result_type>,
+                "rbxx::protect does not support reference return types");
+
+  payload_type payload{std::forward<Function>(function),
+                       std::tuple<std::decay_t<Args>...>{std::forward<Args>(args)...}, std::nullopt,
+                       nullptr};
+  int state = 0;
+  rb_protect(detail::protect_trampoline<payload_type>, reinterpret_cast<VALUE>(&payload), &state);
+
+  if (state != 0) {
+    VALUE exception = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    throw ruby_error(exception);
+  }
+  if (payload.cpp_exception) {
+    std::rethrow_exception(payload.cpp_exception);
+  }
+
+  if constexpr (std::is_void_v<typename payload_type::result_type>) {
+    return;
+  } else {
+    return std::move(*payload.result);
+  }
+}
+
+} // namespace rbxx
+// END rbxx/protect.hpp
+
+// BEGIN rbxx/type_caster.hpp
+
+
+#include <concepts>
+#include <cstddef>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+
+/// @brief Customization point for conversion between Ruby and C++ values.
+/// @code template <> struct rbxx::type_caster<MyType> { /* load/dump/matches */ }; @endcode
+template <typename T, typename Enable = void> struct type_caster;
+
+/// @brief True when T can be converted to a Ruby value.
+template <typename T>
+concept to_ruby_convertible = requires(T&& input) {
+  {
+    type_caster<std::remove_cvref_t<T>>::dump(std::forward<T>(input))
+  } -> std::convertible_to<value>;
+};
+
+/// @brief True when a Ruby value can be converted to T.
+template <typename T>
+concept from_ruby_convertible =
+    requires(value input) { type_caster<std::remove_cvref_t<T>>::load(input); };
+
+namespace detail {
+
+template <typename T> constexpr std::string_view type_name() noexcept {
+#if defined(_MSC_VER)
+  constexpr std::string_view signature = __FUNCSIG__;
+  constexpr std::string_view prefix = "type_name<";
+  const auto start = signature.find(prefix) + prefix.size();
+  return signature.substr(start, signature.find(">(void)", start) - start);
+#else
+  constexpr std::string_view signature = __PRETTY_FUNCTION__;
+  constexpr std::string_view prefix = "T = ";
+  const auto start = signature.find(prefix) + prefix.size();
+  const auto end = signature.find_first_of("];", start);
+  return signature.substr(start, end - start);
+#endif
+}
+
+[[noreturn]] inline void throw_type_error(const char* expected, value actual) {
+  const char* actual_name = rb_obj_classname(actual.raw());
+  std::string message = "rbxx: expected ";
+  message += expected;
+  message += ", got ";
+  message += actual_name;
+  throw ruby_error(make_exception(rb_eTypeError, message.c_str()));
+}
+
+template <typename Integer> Integer load_integer(value input) {
+  if constexpr (std::is_signed_v<Integer>) {
+    const auto converted = protect(rb_num2ll, input.raw());
+    constexpr auto minimum = static_cast<LONG_LONG>(std::numeric_limits<Integer>::min());
+    constexpr auto maximum = static_cast<LONG_LONG>(std::numeric_limits<Integer>::max());
+    if (converted < minimum || converted > maximum) {
+      throw std::range_error("rbxx: Integer is outside the target C++ signed integer range");
+    }
+    return static_cast<Integer>(converted);
+  } else {
+    const auto converted = protect(rb_num2ull, input.raw());
+    constexpr auto maximum = static_cast<unsigned LONG_LONG>(std::numeric_limits<Integer>::max());
+    if (converted > maximum) {
+      throw std::range_error("rbxx: Integer is outside the target C++ unsigned integer range");
+    }
+    return static_cast<Integer>(converted);
+  }
+}
+
+template <typename Integer> value dump_integer(Integer input) {
+  if constexpr (std::is_signed_v<Integer>) {
+    if (RB_FIXABLE(static_cast<LONG_LONG>(input))) {
+      return value{LONG2FIX(static_cast<long>(input))};
+    }
+    return value{protect(rb_ll2inum, static_cast<LONG_LONG>(input))};
+  } else {
+    if (RB_POSFIXABLE(static_cast<unsigned LONG_LONG>(input))) {
+      return value{LONG2FIX(static_cast<long>(input))};
+    }
+    return value{protect(rb_ull2inum, static_cast<unsigned LONG_LONG>(input))};
+  }
+}
+
+inline const char* checked_string_pointer(value input) {
+  if (!input.is_string()) {
+    throw_type_error("String", input);
+  }
+  VALUE raw = input.raw();
+  return protect([raw]() mutable {
+    VALUE string = raw;
+    return StringValueCStr(string);
+  });
+}
+
+inline VALUE checked_string_value(value input) {
+  if (input.is_string()) {
+    return input.raw();
+  }
+  VALUE converted = protect(rb_check_string_type, input.raw());
+  if (NIL_P(converted)) {
+    throw_type_error("String or object responding to #to_str", input);
+  }
+  return converted;
+}
+
+inline value dump_utf8(const char* bytes, std::size_t size) {
+  if (size > static_cast<std::size_t>(std::numeric_limits<long>::max())) {
+    throw std::length_error("rbxx: String is too large for CRuby");
+  }
+  return value{protect(rb_utf8_str_new, bytes, static_cast<long>(size))};
+}
+
+} // namespace detail
+
+template <typename T>
+struct type_caster<T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>>> {
+  static constexpr std::string_view name = "Integer";
+
+  /// @brief Loads a range-checked C++ integer.
+  static T load(value input) { return detail::load_integer<T>(input); }
+
+  /// @brief Dumps a C++ integer as a Ruby Integer.
+  static value dump(T input) { return detail::dump_integer(input); }
+
+  /// @brief Returns whether the Ruby value is an Integer.
+  static bool matches(value input) noexcept { return input.is_integer(); }
+};
+
+template <> struct type_caster<bool> {
+  static constexpr std::string_view name = "Boolean";
+
+  static bool load(value input) {
+    if (!input.is_bool()) {
+      detail::throw_type_error("true or false", input);
+    }
+    return input.raw() == Qtrue;
+  }
+
+  static value dump(bool input) noexcept { return value{input ? Qtrue : Qfalse}; }
+  static bool matches(value input) noexcept { return input.is_bool(); }
+};
+
+template <> struct type_caster<float> {
+  static constexpr std::string_view name = "Float";
+  static float load(value input) {
+    if (input.is_float()) {
+      return static_cast<float>(RFLOAT_VALUE(input.raw()));
+    }
+    return static_cast<float>(protect(rb_num2dbl, input.raw()));
+  }
+  static value dump(float input) {
+    return value{protect(rb_float_new, static_cast<double>(input))};
+  }
+  static bool matches(value input) noexcept { return input.is_float() || input.is_integer(); }
+};
+
+template <> struct type_caster<double> {
+  static constexpr std::string_view name = "Float";
+  static double load(value input) {
+    return input.is_float() ? RFLOAT_VALUE(input.raw()) : protect(rb_num2dbl, input.raw());
+  }
+  static value dump(double input) { return value{protect(rb_float_new, input)}; }
+  static bool matches(value input) noexcept { return input.is_float() || input.is_integer(); }
+};
+
+template <> struct type_caster<const char*> {
+  static constexpr std::string_view name = "String";
+  static const char* load(value input) { return detail::checked_string_pointer(input); }
+  static value dump(const char* input) {
+    if (input == nullptr) {
+      detail::throw_type_error("non-null C string", value{Qnil});
+    }
+    return value{protect(rb_utf8_str_new_cstr, input)};
+  }
+  static bool matches(value input) noexcept { return input.is_string(); }
+};
+
+template <> struct type_caster<std::string> {
+  static constexpr std::string_view name = "String";
+  static std::string load(value input) {
+    VALUE converted = detail::checked_string_value(input);
+    const char* bytes = protect([converted]() mutable {
+      VALUE string = converted;
+      return StringValueCStr(string);
+    });
+    return std::string(bytes, static_cast<std::size_t>(RSTRING_LEN(converted)));
+  }
+  static value dump(const std::string& input) {
+    return detail::dump_utf8(input.data(), input.size());
+  }
+  static bool matches(value input) noexcept { return input.is_string(); }
+};
+
+template <> struct type_caster<std::string_view> {
+  static constexpr std::string_view name = "String";
+  static std::string_view load(value input) {
+    const char* bytes = detail::checked_string_pointer(input);
+    return std::string_view(bytes, static_cast<std::size_t>(RSTRING_LEN(input.raw())));
+  }
+  static value dump(std::string_view input) {
+    return detail::dump_utf8(input.data(), input.size());
+  }
+  static bool matches(value input) noexcept { return input.is_string(); }
+};
+
+template <> struct type_caster<value> {
+  static constexpr std::string_view name = "Object";
+  static value load(value input) noexcept { return input; }
+  static value dump(value input) noexcept { return input; }
+  static bool matches(value) noexcept { return true; }
+};
+
+template <> struct type_caster<object> {
+  static constexpr std::string_view name = "Object";
+  static object load(value input) { return object{input}; }
+  static value dump(const object& input) noexcept { return input.get(); }
+  static bool matches(value) noexcept { return true; }
+};
+
+/// @brief Converts a C++ value to Ruby with an actionable missing-caster diagnostic.
+/// @code rbxx::value result = rbxx::to_ruby(42); @endcode
+template <typename T> [[nodiscard]] value to_ruby(T&& input) {
+  using converted_type = std::remove_cvref_t<T>;
+  static_assert(to_ruby_convertible<converted_type>,
+                "rbxx: type has no type_caster; bind it with def_class<T>() or specialize "
+                "rbxx::type_caster<T>");
+  return type_caster<converted_type>::dump(std::forward<T>(input));
+}
+
+/// @brief Converts a Ruby value to C++ with an actionable missing-caster diagnostic.
+/// @code int result = rbxx::from_ruby<int>(ruby_value); @endcode
+template <typename T> [[nodiscard]] decltype(auto) from_ruby(value input) {
+  using converted_type = std::remove_cvref_t<T>;
+  static_assert(from_ruby_convertible<converted_type>,
+                "rbxx: type has no type_caster; bind it with def_class<T>() or specialize "
+                "rbxx::type_caster<T>");
+  return type_caster<converted_type>::load(input);
+}
+
+} // namespace rbxx
+// END rbxx/type_caster.hpp
+
+// BEGIN rbxx/arg.hpp
+
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace rbxx {
+
+struct argument_spec {
+  std::string name;
+  bool keyword = false;
+  bool has_default = false;
+  object default_value;
+};
+
+/// @brief Declares a named positional argument and an optional default.
+/// @code function.def("add", fn, rbxx::arg("delta") = 1); @endcode
+class arg {
+public:
+  explicit arg(const char* name) : name_(name) {}
+  operator argument_spec() const { return argument_spec{name_, false, false, {}}; }
+
+  template <typename T> argument_spec operator=(T&& default_value) const {
+    return argument_spec{name_, false, true, object{to_ruby(std::forward<T>(default_value))}};
+  }
+
+private:
+  std::string name_;
+};
+
+/// @brief Declares a keyword argument and an optional default.
+/// @code function.def("open", fn, rbxx::kwarg("mode") = "fast"); @endcode
+class kwarg {
+public:
+  explicit kwarg(const char* name) : name_(name) {}
+  operator argument_spec() const { return argument_spec{name_, true, false, {}}; }
+
+  template <typename T> argument_spec operator=(T&& default_value) const {
+    return argument_spec{name_, true, true, object{to_ruby(std::forward<T>(default_value))}};
+  }
+
+private:
+  std::string name_;
+};
+
+/// @brief Required Ruby block passed to a bound C++ callable.
+class block {
+public:
+  explicit block(value callable) : callable_(callable) {}
+
+  [[nodiscard]] value get() const noexcept { return callable_.get(); }
+
+  template <typename Return = value, typename... Args> Return call(Args&&... args) const {
+    std::array<VALUE, sizeof...(Args)> arguments{to_ruby(std::forward<Args>(args)).raw()...};
+    VALUE result = protect(rb_funcallv, callable_.raw(), rb_intern("call"),
+                           static_cast<int>(sizeof...(Args)), arguments.data());
+    if constexpr (std::is_same_v<Return, value>) {
+      return value{result};
+    } else {
+      return from_ruby<Return>(value{result});
+    }
+  }
+
+private:
+  object callable_;
+};
+
+/// @brief Optional Ruby block passed to a bound C++ callable.
+class optional_block {
+public:
+  optional_block() = default;
+  explicit optional_block(value callable) : callable_(callable) {}
+
+  [[nodiscard]] explicit operator bool() const noexcept { return !callable_.is_nil(); }
+  [[nodiscard]] value get() const noexcept { return callable_.get(); }
+
+  template <typename Return = value, typename... Args> Return call(Args&&... args) const {
+    if (!*this) {
+      throw std::invalid_argument("rbxx: optional block is not present");
+    }
+    return block{callable_.get()}.template call<Return>(std::forward<Args>(args)...);
+  }
+
+private:
+  object callable_;
+};
+
+/// @brief Remaining positional Ruby arguments.
+class args {
+public:
+  explicit args(std::vector<value> values) : values_(std::move(values)) {}
+  [[nodiscard]] const std::vector<value>& values() const noexcept { return values_; }
+  [[nodiscard]] std::size_t size() const noexcept { return values_.size(); }
+  [[nodiscard]] value operator[](std::size_t index) const { return values_.at(index); }
+
+private:
+  std::vector<value> values_;
+};
+
+template <> struct type_caster<block> {
+  static block load(value input) { return block{input}; }
+  static value dump(const block& input) noexcept { return input.get(); }
+  static bool matches(value input) noexcept { return RTEST(rb_obj_is_proc(input.raw())); }
+};
+
+template <> struct type_caster<optional_block> {
+  static optional_block load(value input) {
+    return input.is_nil() ? optional_block{} : optional_block{input};
+  }
+  static value dump(const optional_block& input) noexcept {
+    return input ? input.get() : value{Qnil};
+  }
+  static bool matches(value input) noexcept {
+    return input.is_nil() || RTEST(rb_obj_is_proc(input.raw()));
+  }
+};
+
+template <> struct type_caster<args> {
+  static args load(value input) { return args{{input}}; }
+  static value dump(const args& input) {
+    return value{protect([&input] {
+      VALUE result = rb_ary_new_capa(static_cast<long>(input.size()));
+      for (value element : input.values()) {
+        rb_ary_push(result, element.raw());
+      }
+      return result;
+    })};
+  }
+  static bool matches(value) noexcept { return true; }
+};
+
+namespace detail {
+
+template <typename Argument> auto load_argument(value input) {
+  using loaded_type = decltype(from_ruby<Argument>(input));
+  if constexpr (std::is_lvalue_reference_v<loaded_type>) {
+    return std::ref(from_ruby<Argument>(input));
+  } else {
+    return from_ruby<Argument>(input);
+  }
+}
+
+template <typename T>
+inline constexpr bool is_block_argument_v = std::is_same_v<std::remove_cvref_t<T>, block>;
+template <typename T>
+inline constexpr bool is_optional_block_argument_v =
+    std::is_same_v<std::remove_cvref_t<T>, optional_block>;
+template <typename T>
+inline constexpr bool is_rest_argument_v = std::is_same_v<std::remove_cvref_t<T>, args>;
+template <typename T>
+inline constexpr bool is_special_argument_v =
+    is_block_argument_v<T> || is_optional_block_argument_v<T> || is_rest_argument_v<T>;
+
+template <typename Tuple, std::size_t... Index>
+consteval std::size_t normal_argument_count(std::index_sequence<Index...>) {
+  return (std::size_t{0} + ... +
+          (is_special_argument_v<std::tuple_element_t<Index, Tuple>> ? 0U : 1U));
+}
+
+template <typename Tuple> consteval std::size_t normal_argument_count() {
+  return normal_argument_count<Tuple>(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+}
+
+inline std::vector<argument_spec> make_argument_specs() { return {}; }
+
+template <typename... Specs> std::vector<argument_spec> make_argument_specs(Specs&&... specs) {
+  static_assert((std::is_convertible_v<Specs, argument_spec> && ...),
+                "rbxx: binding options must be arg(...) or kwarg(...)");
+  std::vector<argument_spec> result;
+  result.reserve(sizeof...(Specs));
+  (result.emplace_back(static_cast<argument_spec>(std::forward<Specs>(specs))), ...);
+  return result;
+}
+
+struct parsed_arguments {
+  std::vector<value> slots;
+  std::vector<value> rest;
+  value block_value{Qnil};
+};
+
+template <typename Tuple> class argument_parser {
+public:
+  static constexpr std::size_t arity = std::tuple_size_v<Tuple>;
+
+  explicit argument_parser(std::vector<argument_spec> specs) : specs_(std::move(specs)) {
+    constexpr std::size_t normal = normal_argument_count<Tuple>();
+    if (specs_.empty()) {
+      specs_.reserve(normal);
+      for (std::size_t index = 0; index < normal; ++index) {
+        specs_.push_back(argument_spec{"arg" + std::to_string(index + 1U), false, false, {}});
+      }
+    }
+    if (specs_.size() != normal) {
+      throw std::invalid_argument("rbxx: argument annotations must match non-block parameters");
+    }
+  }
+
+  [[nodiscard]] parsed_arguments parse(int argc, const VALUE* argv) const {
+    parsed_arguments parsed;
+    parsed.slots.resize(arity, value{Qundef});
+
+    int positional_count = argc;
+    VALUE keywords = Qnil;
+    if (argc > 0 && rb_keyword_given_p()) {
+      keywords = argv[argc - 1];
+      --positional_count;
+    }
+
+    std::vector<VALUE> keyword_values(specs_.size(), Qundef);
+    read_keywords(keywords, keyword_values);
+    fill_slots(parsed, positional_count, argv, keyword_values, std::make_index_sequence<arity>{});
+    read_block(parsed);
+    return parsed;
+  }
+
+  [[nodiscard]] bool configured() const noexcept {
+    return std::any_of(specs_.begin(), specs_.end(),
+                       [](const argument_spec& spec) { return spec.keyword || spec.has_default; });
+  }
+
+private:
+  void read_keywords(VALUE keywords, std::vector<VALUE>& values) const {
+    std::vector<ID> required;
+    std::vector<ID> optional;
+    std::vector<std::size_t> required_order;
+    std::vector<std::size_t> optional_order;
+    for (std::size_t index = 0; index < specs_.size(); ++index) {
+      const auto& spec = specs_[index];
+      if (!spec.keyword) {
+        continue;
+      }
+      ID id = protect(rb_intern, spec.name.c_str());
+      (spec.has_default ? optional : required).push_back(id);
+      (spec.has_default ? optional_order : required_order).push_back(index);
+    }
+
+    if (required.empty() && optional.empty()) {
+      if (!NIL_P(keywords) && RHASH_SIZE(keywords) != 0) {
+        throw ruby_error(make_exception(rb_eArgError, "rbxx: unknown keyword arguments"));
+      }
+      return;
+    }
+
+    if (NIL_P(keywords)) {
+      keywords = protect(rb_hash_new);
+    }
+    std::vector<ID> table = required;
+    table.insert(table.end(), optional.begin(), optional.end());
+    std::vector<std::size_t> order = required_order;
+    order.insert(order.end(), optional_order.begin(), optional_order.end());
+    std::vector<VALUE> extracted(table.size(), Qundef);
+    protect([&] {
+      return rb_get_kwargs(keywords, table.data(), static_cast<int>(required.size()),
+                           static_cast<int>(optional.size()), extracted.data());
+    });
+    for (std::size_t index = 0; index < order.size(); ++index) {
+      values[order[index]] = extracted[index];
+    }
+  }
+
+  template <std::size_t... Index>
+  void fill_slots(parsed_arguments& parsed, int positional_count, const VALUE* argv,
+                  const std::vector<VALUE>& keyword_values, std::index_sequence<Index...>) const {
+    std::size_t spec_index = 0;
+    int positional_index = 0;
+    (fill_slot<Index>(parsed, positional_count, positional_index, argv, spec_index, keyword_values),
+     ...);
+    if (positional_index < positional_count && !has_rest(std::make_index_sequence<arity>{})) {
+      throw ruby_error(make_exception(rb_eArgError, "rbxx: too many positional arguments"));
+    }
+  }
+
+  template <std::size_t Index>
+  void fill_slot(parsed_arguments& parsed, int positional_count, int& positional_index,
+                 const VALUE* argv, std::size_t& spec_index,
+                 const std::vector<VALUE>& keyword_values) const {
+    using argument = std::tuple_element_t<Index, Tuple>;
+    if constexpr (is_rest_argument_v<argument>) {
+      while (positional_index < positional_count) {
+        parsed.rest.emplace_back(argv[positional_index++]);
+      }
+    } else if constexpr (!is_block_argument_v<argument> &&
+                         !is_optional_block_argument_v<argument>) {
+      const argument_spec& spec = specs_[spec_index];
+      VALUE selected = Qundef;
+      if (spec.keyword) {
+        selected = keyword_values[spec_index];
+      } else if (positional_index < positional_count) {
+        selected = argv[positional_index++];
+      }
+      if (selected == Qundef && spec.has_default) {
+        selected = spec.default_value.raw();
+      }
+      if (selected == Qundef) {
+        std::string message = "rbxx: missing argument ";
+        message += spec.name;
+        throw ruby_error(make_exception(rb_eArgError, message.c_str()));
+      }
+      parsed.slots[Index] = value{selected};
+      ++spec_index;
+    }
+  }
+
+  void read_block(parsed_arguments& parsed) const {
+    constexpr bool required = contains_required_block(std::make_index_sequence<arity>{});
+    if (rb_block_given_p()) {
+      parsed.block_value = value{protect(rb_block_proc)};
+    } else if (required) {
+      throw ruby_error(make_exception(rb_eArgError, "rbxx: required block was not given"));
+    }
+  }
+
+  template <std::size_t... Index>
+  static consteval bool contains_required_block(std::index_sequence<Index...>) {
+    return (is_block_argument_v<std::tuple_element_t<Index, Tuple>> || ...);
+  }
+
+  template <std::size_t... Index> static consteval bool has_rest(std::index_sequence<Index...>) {
+    return (is_rest_argument_v<std::tuple_element_t<Index, Tuple>> || ...);
+  }
+
+  std::vector<argument_spec> specs_;
+};
+
+template <typename Argument>
+auto load_parsed_argument(const parsed_arguments& parsed, std::size_t index) {
+  if constexpr (is_block_argument_v<Argument>) {
+    return block{parsed.block_value};
+  } else if constexpr (is_optional_block_argument_v<Argument>) {
+    return parsed.block_value.is_nil() ? optional_block{} : optional_block{parsed.block_value};
+  } else if constexpr (is_rest_argument_v<Argument>) {
+    return args{parsed.rest};
+  } else {
+    return load_argument<Argument>(parsed.slots[index]);
+  }
+}
+
+} // namespace detail
+
+} // namespace rbxx
+// END rbxx/arg.hpp
+
+// BEGIN rbxx/policies.hpp
+
+#include <cstddef>
+
+namespace rbxx {
+
+namespace policy {
+
+/// @brief Internal value carried by a public return-value policy constant.
+enum class kind { automatic, copy, take, reference, shared };
+
+/// @brief Selects ownership behavior when converting a C++ return value to Ruby.
+struct return_value_policy {
+  kind value;
+};
+
+/// @name Return-value policies
+/// @{
+inline constexpr return_value_policy automatic{kind::automatic};
+inline constexpr return_value_policy copy{kind::copy};
+inline constexpr return_value_policy take{kind::take};
+inline constexpr return_value_policy reference{kind::reference};
+inline constexpr return_value_policy shared{kind::shared};
+/// @}
+
+} // namespace policy
+
+/// @brief Keeps one Ruby object alive for as long as another remains reachable.
+/// @details Index 0 is the return value, 1 is self, and 2 onward are arguments.
+/// @code .def("child", &Owner::child, policy::reference, keep_alive<0, 1>()) @endcode
+template <std::size_t Nurse, std::size_t Patient> struct keep_alive {
+  static constexpr std::size_t nurse = Nurse;
+  static constexpr std::size_t patient = Patient;
+};
+
+} // namespace rbxx
+// END rbxx/policies.hpp
+
+// BEGIN rbxx/registry.hpp
+
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <source_location>
+#include <string>
+#include <typeindex>
+#include <unordered_map>
+
+namespace rbxx::detail {
+
+struct class_info {
+  std::type_index cpp_type{typeid(void)};
+  VALUE ruby_class = Qnil;
+  const rb_data_type_t* data_type = nullptr;
+  std::function<void*(void*)> native_pointer;
+  std::unordered_map<std::type_index, std::function<void*(void*)>> conversions;
+  std::source_location registered_at = std::source_location::current();
+};
+
+class type_registry {
+public:
+  static type_registry& instance() {
+    static auto* registry = new type_registry();
+    return *registry;
+  }
+
+  template <typename T, typename Base = void>
+  void add(VALUE ruby_class, const rb_data_type_t* data_type,
+           std::source_location location = std::source_location::current()) {
+    auto information = std::make_unique<class_info>();
+    information->cpp_type = std::type_index(typeid(T));
+    information->ruby_class = ruby_class;
+    information->data_type = data_type;
+    information->conversions.emplace(std::type_index(typeid(T)),
+                                     [](void* pointer) { return pointer; });
+    information->registered_at = location;
+
+    if constexpr (!std::is_void_v<Base>) {
+      class_info* base = find(std::type_index(typeid(Base)));
+      if (base == nullptr) {
+        std::string message = "rbxx: base C++ type ";
+        message += type_name<Base>();
+        message += " is not registered; call def_class<Base>() first";
+        throw ruby_error(make_exception(rb_eTypeError, message.c_str()));
+      }
+      for (const auto& [target, conversion] : base->conversions) {
+        information->conversions.emplace(target, [conversion](void* pointer) {
+          auto* derived = static_cast<T*>(pointer);
+          return conversion(static_cast<Base*>(derived));
+        });
+      }
+    }
+
+    std::lock_guard lock(write_mutex_);
+    class_info* stored = information.get();
+    by_data_type_.insert_or_assign(data_type, stored);
+    by_type_.insert_or_assign(std::type_index(typeid(T)), std::move(information));
+  }
+
+  template <typename T> void set_native_pointer(std::function<void*(void*)> extractor) {
+    class_info* information = find(std::type_index(typeid(T)));
+    if (information != nullptr) {
+      information->native_pointer = std::move(extractor);
+    }
+  }
+
+  [[nodiscard]] class_info* find(std::type_index type) const noexcept {
+    auto found = by_type_.find(type);
+    return found == by_type_.end() ? nullptr : found->second.get();
+  }
+
+  [[nodiscard]] class_info* find(const rb_data_type_t* type) const noexcept {
+    auto found = by_data_type_.find(type);
+    return found == by_data_type_.end() ? nullptr : found->second;
+  }
+
+private:
+  std::mutex write_mutex_;
+  std::unordered_map<std::type_index, std::unique_ptr<class_info>> by_type_;
+  std::unordered_map<const rb_data_type_t*, class_info*> by_data_type_;
+};
+
+template <typename T> [[noreturn]] void throw_unregistered_type() {
+  std::string message = "rbxx: C++ type ";
+  message += type_name<T>();
+  message += " is not registered; call def_class<T>() or specialize rbxx::type_caster<T>";
+  throw ruby_error(make_exception(rb_eTypeError, message.c_str()));
+}
+
+template <typename T> class_info& registered_class() {
+  class_info* information = type_registry::instance().find(std::type_index(typeid(T)));
+  if (information == nullptr) {
+    throw_unregistered_type<T>();
+  }
+  return *information;
+}
+
+template <typename T> T& load_registered(value input) {
+  VALUE raw = input.raw();
+  if (!RB_TYPE_P(raw, T_DATA) || !RTYPEDDATA_P(raw)) {
+    std::string message = "rbxx: expected registered C++ type ";
+    message += type_name<T>();
+    message += ", got ";
+    message += rb_obj_classname(raw);
+    message += "; call def_class<T>() for the expected type";
+    throw ruby_error(make_exception(rb_eTypeError, message.c_str()));
+  }
+
+  class_info* actual = type_registry::instance().find(RTYPEDDATA_TYPE(raw));
+  if (actual == nullptr || !actual->native_pointer) {
+    throw_unregistered_type<T>();
+  }
+  auto conversion = actual->conversions.find(std::type_index(typeid(T)));
+  if (conversion == actual->conversions.end()) {
+    std::string message = "rbxx: wrapped C++ type cannot be converted to ";
+    message += type_name<T>();
+    message += "; register the inheritance with def_class<Derived, Base>()";
+    message += "; actual type was registered at ";
+    message += actual->registered_at.file_name();
+    message += ":";
+    message += std::to_string(actual->registered_at.line());
+    throw ruby_error(make_exception(rb_eTypeError, message.c_str()));
+  }
+
+  void* native = actual->native_pointer(RTYPEDDATA_DATA(raw));
+  if (native == nullptr) {
+    throw ruby_error(make_exception(rb_eRuntimeError, "rbxx: C++ object is not initialized"));
+  }
+  return *static_cast<T*>(conversion->second(native));
+}
+
+template <typename T> bool registered_matches(value input) noexcept {
+  if (!RB_TYPE_P(input.raw(), T_DATA) || !RTYPEDDATA_P(input.raw())) {
+    return false;
+  }
+  class_info* actual = type_registry::instance().find(RTYPEDDATA_TYPE(input.raw()));
+  return actual != nullptr &&
+         actual->conversions.contains(std::type_index(typeid(std::remove_cv_t<T>)));
+}
+
+} // namespace rbxx::detail
+// END rbxx/registry.hpp
+
+// BEGIN rbxx/data_object.hpp
+
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+
+/// @brief A Ruby VALUE member that remains marked and compaction-safe inside a C++ object.
+/// @code rbxx::member_value child{ruby_child}; @endcode
+class member_value {
+public:
+  member_value() noexcept { rb_gc_register_address(&stored_); }
+  explicit member_value(value initial) noexcept : stored_(initial.raw()) {
+    rb_gc_register_address(&stored_);
+  }
+  explicit member_value(VALUE initial) noexcept : stored_(initial) {
+    rb_gc_register_address(&stored_);
+  }
+  member_value(const member_value& other) noexcept : stored_(other.stored_) {
+    rb_gc_register_address(&stored_);
+  }
+  member_value(member_value&& other) noexcept : stored_(other.stored_) {
+    rb_gc_register_address(&stored_);
+    other.stored_ = Qnil;
+  }
+  member_value& operator=(const member_value& other) noexcept {
+    stored_ = other.stored_;
+    return *this;
+  }
+  member_value& operator=(member_value&& other) noexcept {
+    stored_ = other.stored_;
+    other.stored_ = Qnil;
+    return *this;
+  }
+  ~member_value() noexcept { rb_gc_unregister_address(&stored_); }
+
+  [[nodiscard]] value get() const noexcept { return value{stored_}; }
+  void set(value updated) noexcept { stored_ = updated.raw(); }
+
+private:
+  VALUE stored_ = Qnil;
+};
+
+namespace detail {
+
+template <typename T> struct is_non_bindable_class : std::false_type {};
+template <typename T> struct is_non_bindable_class<std::unique_ptr<T>> : std::true_type {};
+template <typename T> struct is_non_bindable_class<std::shared_ptr<T>> : std::true_type {};
+
+enum class ownership { owned, borrowed, shared };
+
+template <typename T> struct data_wrapper {
+  T* pointer = nullptr;
+  ownership mode = ownership::borrowed;
+  std::shared_ptr<T> shared_owner;
+
+  ~data_wrapper() noexcept {
+    if (mode == ownership::owned) {
+      delete pointer;
+    }
+  }
+};
+
+template <typename T> void data_mark(void*) noexcept {}
+template <typename T> void data_compact(void*) noexcept {}
+
+template <typename T> void data_free(void* raw) noexcept {
+  delete static_cast<data_wrapper<T>*>(raw);
+}
+
+template <typename T> std::size_t data_size(const void* raw) noexcept {
+  const auto* wrapper = static_cast<const data_wrapper<T>*>(raw);
+  return sizeof(data_wrapper<T>) +
+         (wrapper != nullptr && wrapper->pointer != nullptr ? sizeof(T) : 0U);
+}
+
+template <typename T> rb_data_type_t& typed_data_type() {
+  static auto* name = new std::string("rbxx::" + std::string(type_name<T>()));
+  static rb_data_type_t type = {
+      name->c_str(),
+      {data_mark<T>, data_free<T>, data_size<T>, data_compact<T>, {nullptr}},
+      nullptr,
+      nullptr,
+      RUBY_TYPED_FREE_IMMEDIATELY,
+  };
+  return type;
+}
+
+template <typename T> value wrap_data(std::unique_ptr<data_wrapper<T>> wrapper) {
+  class_info& information = registered_class<T>();
+  VALUE result = protect(rb_data_typed_object_wrap, information.ruby_class,
+                         static_cast<void*>(wrapper.get()), information.data_type);
+  wrapper.release();
+  return value{result};
+}
+
+template <typename T> value wrap_copy(const T& input) {
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = new T(input);
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_move(T&& input) {
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = new T(std::move(input));
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_reference(T* input) {
+  if (input == nullptr) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input;
+  wrapper->mode = ownership::borrowed;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_take(std::unique_ptr<T> input) {
+  if (!input) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input.release();
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_shared(std::shared_ptr<T> input) {
+  if (!input) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input.get();
+  wrapper->mode = ownership::shared;
+  wrapper->shared_owner = std::move(input);
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T, typename Base = void>
+void register_data_class(VALUE ruby_class,
+                         std::source_location location = std::source_location::current()) {
+  rb_data_type_t& type = typed_data_type<T>();
+  if constexpr (!std::is_void_v<Base>) {
+    type.parent = &typed_data_type<Base>();
+  }
+  type_registry::instance().add<T, Base>(ruby_class, &type, location);
+  type_registry::instance().set_native_pointer<T>(
+      [](void* raw) { return static_cast<void*>(static_cast<data_wrapper<T>*>(raw)->pointer); });
+}
+
+template <typename T> VALUE allocate_data_object(VALUE klass) {
+  VALUE result = Qnil;
+  VALUE pending = Qnil;
+  try {
+    auto wrapper = std::make_unique<data_wrapper<T>>();
+    result = protect(rb_data_typed_object_wrap, klass, static_cast<void*>(wrapper.get()),
+                     &typed_data_type<T>());
+    wrapper.release();
+  } catch (...) {
+    pending = translate_current_exception();
+  }
+  if (!NIL_P(pending)) {
+    rb_exc_raise(pending);
+  }
+  return result;
+}
+
+template <typename T> data_wrapper<T>& exact_wrapper(value self) {
+  if (!RB_TYPE_P(self.raw(), T_DATA) || !RTYPEDDATA_P(self.raw()) ||
+      RTYPEDDATA_TYPE(self.raw()) != &typed_data_type<T>()) {
+    throw ruby_error(make_exception(rb_eTypeError, "rbxx: unexpected TypedData class"));
+  }
+  return *static_cast<data_wrapper<T>*>(RTYPEDDATA_DATA(self.raw()));
+}
+
+} // namespace detail
+
+template <typename T>
+struct type_caster<T, std::enable_if_t<std::is_class_v<T> && !std::is_same_v<T, object> &&
+                                       !detail::is_non_bindable_class<T>::value>> {
+  static constexpr std::string_view name = "bound C++ object";
+  static T& load(value input) { return detail::load_registered<T>(input); }
+  static value dump(const T& input) { return detail::wrap_copy(input); }
+  static value dump(T&& input) { return detail::wrap_move(std::move(input)); }
+  static bool matches(value input) noexcept { return detail::registered_matches<T>(input); }
+};
+
+template <typename T> struct type_caster<T*> {
+  static constexpr std::string_view name = "bound C++ object or nil";
+  static T* load(value input) {
+    return input.is_nil() ? nullptr : std::addressof(detail::load_registered<T>(input));
+  }
+  static value dump(T* input) { return detail::wrap_reference(input); }
+  static bool matches(value input) noexcept {
+    return input.is_nil() || detail::registered_matches<T>(input);
+  }
+};
+
+template <typename T> struct type_caster<std::unique_ptr<T>> {
+  static constexpr std::string_view name = "owned C++ object";
+  static value dump(std::unique_ptr<T> input) { return detail::wrap_take(std::move(input)); }
+  static bool matches(value) noexcept { return false; }
+};
+
+template <typename T> struct type_caster<std::shared_ptr<T>> {
+  static constexpr std::string_view name = "shared C++ object";
+  static value dump(std::shared_ptr<T> input) { return detail::wrap_shared(std::move(input)); }
+  static bool matches(value input) noexcept {
+    return RB_TYPE_P(input.raw(), T_DATA) && RTYPEDDATA_P(input.raw());
+  }
+};
+
+} // namespace rbxx
+// END rbxx/data_object.hpp
+
+// BEGIN rbxx/callback.hpp
+
+
+#include <array>
+#include <functional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+
+namespace detail {
+
+template <typename Return, typename... Args>
+struct is_non_bindable_class<std::function<Return(Args...)>> : std::true_type {};
+
+inline void require_callback_gvl() {
+#if defined(RBXX_DEBUG)
+  if (ruby_thread_has_gvl_p() == 0) {
+    throw std::runtime_error(
+        "rbxx: Ruby callback invoked without the GVL; reacquire it before calling the Proc");
+  }
+#endif
+}
+
+} // namespace detail
+
+/// @brief Converts a Ruby Proc into a GC-pinned C++ std::function.
+template <typename Return, typename... Args> struct type_caster<std::function<Return(Args...)>> {
+  static constexpr std::string_view name = "Proc";
+
+  static std::function<Return(Args...)> load(value input) {
+    if (!matches(input)) {
+      detail::throw_type_error("Proc", input);
+    }
+    object callable{input};
+    return [callable = std::move(callable)](Args... args) -> Return {
+      detail::require_callback_gvl();
+      std::array<VALUE, sizeof...(Args)> converted{to_ruby(std::forward<Args>(args)).raw()...};
+      VALUE result = protect(rb_funcallv, callable.raw(), rb_intern("call"),
+                             static_cast<int>(converted.size()), converted.data());
+      if constexpr (std::is_void_v<Return>) {
+        return;
+      } else {
+        return from_ruby<Return>(value{result});
+      }
+    };
+  }
+
+  static bool matches(value input) noexcept { return RTEST(rb_obj_is_proc(input.raw())); }
+};
+
+} // namespace rbxx
+// END rbxx/callback.hpp
+
+// BEGIN rbxx/function.hpp
+
+
+#include <functional>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace rbxx::detail {
+
+struct keep_alive_spec {
+  std::size_t nurse;
+  std::size_t patient;
+};
+
+template <std::size_t Nurse, std::size_t Patient>
+constexpr keep_alive_spec make_keep_alive_spec(keep_alive<Nurse, Patient>) noexcept {
+  return {Nurse, Patient};
+}
+
+inline value keep_alive_value(std::size_t index, value result, value self, int argc,
+                              const VALUE* argv) {
+  if (index == 0U) {
+    return result;
+  }
+  if (index == 1U) {
+    return self;
+  }
+  const std::size_t argument = index - 2U;
+  if (argument >= static_cast<std::size_t>(argc)) {
+    throw std::out_of_range("rbxx: keep_alive index exceeds the Ruby argument count");
+  }
+  return value{argv[argument]};
+}
+
+inline void apply_keep_alive(const std::vector<keep_alive_spec>& policies, value result, value self,
+                             int argc, const VALUE* argv) {
+  for (const keep_alive_spec& selected : policies) {
+    value nurse = keep_alive_value(selected.nurse, result, self, argc, argv);
+    value patient = keep_alive_value(selected.patient, result, self, argc, argv);
+    if (nurse.is_nil() || patient.is_nil()) {
+      continue;
+    }
+    if (selected.nurse > static_cast<std::size_t>(std::numeric_limits<unsigned int>::max())) {
+      throw std::out_of_range("rbxx: keep_alive nurse index is too large");
+    }
+    std::string name = "@__rbxx_keep_" + std::to_string(selected.nurse);
+    protect([nurse, patient, &name] {
+      ID id = rb_intern(name.c_str());
+      VALUE storage = rb_ivar_get(nurse.raw(), id);
+      if (NIL_P(storage)) {
+        storage = rb_ary_new();
+        rb_ivar_set(nurse.raw(), id, storage);
+      } else if (!RB_TYPE_P(storage, T_ARRAY)) {
+        rb_raise(rb_eTypeError, "rbxx: keep_alive storage was replaced with a non-Array");
+      }
+      rb_ary_push(storage, patient.raw());
+    });
+  }
+}
+
+template <typename T> struct function_traits;
+
+template <typename Return, typename... Args> struct function_traits<Return(Args...)> {
+  using return_type = Return;
+  using args_tuple = std::tuple<Args...>;
+  static constexpr std::size_t arity = sizeof...(Args);
+};
+
+template <typename Return, typename... Args>
+struct function_traits<Return (*)(Args...)> : function_traits<Return(Args...)> {};
+
+template <typename Return, typename... Args>
+struct function_traits<Return (*)(Args...) noexcept> : function_traits<Return(Args...)> {};
+
+template <typename Return, typename... Args>
+struct function_traits<std::function<Return(Args...)>> : function_traits<Return(Args...)> {};
+
+template <typename Class, typename Return, typename... Args>
+struct function_traits<Return (Class::*)(Args...)> : function_traits<Return(Args...)> {};
+
+template <typename Class, typename Return, typename... Args>
+struct function_traits<Return (Class::*)(Args...) const> : function_traits<Return(Args...)> {};
+
+template <typename Class, typename Return, typename... Args>
+struct function_traits<Return (Class::*)(Args...) noexcept> : function_traits<Return(Args...)> {};
+
+template <typename Class, typename Return, typename... Args>
+struct function_traits<Return (Class::*)(Args...) const noexcept>
+    : function_traits<Return(Args...)> {};
+
+template <typename T, typename = void> struct resolved_function_traits {};
+
+template <typename T>
+struct resolved_function_traits<T, std::void_t<decltype(&std::remove_reference_t<T>::operator())>>
+    : function_traits<decltype(&std::remove_reference_t<T>::operator())> {};
+
+template <typename T>
+  requires std::is_function_v<std::remove_pointer_t<std::decay_t<T>>>
+struct resolved_function_traits<T, void> : function_traits<std::decay_t<T>> {};
+
+template <typename Return, typename... Args>
+struct resolved_function_traits<std::function<Return(Args...)>, void>
+    : function_traits<std::function<Return(Args...)>> {};
+
+template <typename T>
+concept function_signature = requires {
+  typename resolved_function_traits<std::decay_t<T>>::return_type;
+  typename resolved_function_traits<std::decay_t<T>>::args_tuple;
+};
+
+template <typename Argument> int argument_match_score(value input) noexcept {
+  using type = std::remove_cvref_t<Argument>;
+  if constexpr (is_special_argument_v<type>) {
+    return 0;
+  } else if constexpr (std::is_integral_v<type> && !std::is_same_v<type, bool>) {
+    return input.is_integer() ? 2 : 0;
+  } else if constexpr (std::is_floating_point_v<type>) {
+    return input.is_float() ? 2 : (input.is_integer() ? 1 : 0);
+  } else if constexpr (std::is_same_v<type, std::string> ||
+                       std::is_same_v<type, std::string_view> ||
+                       std::is_same_v<type, const char*>) {
+    return input.is_string() ? 2 : 0;
+  } else if constexpr (std::is_same_v<type, value> || std::is_same_v<type, object>) {
+    return 1;
+  } else {
+    return type_caster<type>::matches(input) ? 2 : 0;
+  }
+}
+
+template <typename Tuple, std::size_t... Index>
+int tuple_match_score(int argc, const VALUE* argv, std::index_sequence<Index...>) noexcept {
+  if (argc != static_cast<int>(sizeof...(Index))) {
+    return -1;
+  }
+  std::array<int, sizeof...(Index)> scores{
+      argument_match_score<std::tuple_element_t<Index, Tuple>>(value{argv[Index]})...};
+  int total = 0;
+  for (int score : scores) {
+    if (score == 0) {
+      return -1;
+    }
+    total += score;
+  }
+  return total;
+}
+
+template <typename Tuple, std::size_t... Index>
+consteval bool arguments_convertible(std::index_sequence<Index...>) {
+  return (from_ruby_convertible<std::tuple_element_t<Index, Tuple>> && ...);
+}
+
+template <typename Function> consteval bool function_arguments_convertible() {
+  using traits = resolved_function_traits<std::decay_t<Function>>;
+  using args = typename traits::args_tuple;
+  return arguments_convertible<args>(std::make_index_sequence<std::tuple_size_v<args>>{});
+}
+
+template <typename Function> consteval bool function_return_convertible() {
+  using result = typename resolved_function_traits<std::decay_t<Function>>::return_type;
+  return std::is_void_v<result> || to_ruby_convertible<result>;
+}
+
+template <typename Result> value dump_result(Result&& result, policy::kind selected);
+
+class native_function {
+public:
+  native_function() = default;
+  native_function(const native_function&) = delete;
+  native_function& operator=(const native_function&) = delete;
+  virtual ~native_function() = default;
+
+  [[nodiscard]] virtual value invoke(int argc, const VALUE* argv, value self) = 0;
+  [[nodiscard]] virtual std::string signature() const = 0;
+  [[nodiscard]] virtual bool accepts_arity(int argc) const noexcept = 0;
+  [[nodiscard]] virtual int match_score(int argc, const VALUE* argv) const noexcept = 0;
+  [[nodiscard]] virtual std::size_t declared_arity() const noexcept = 0;
+};
+
+template <typename Function> class native_function_impl final : public native_function {
+public:
+  explicit native_function_impl(Function function, std::vector<argument_spec> specs = {})
+      : function_(std::move(function)), parser_(std::move(specs)) {}
+
+  [[nodiscard]] value invoke(int argc, const VALUE* argv, value) override {
+    using traits = resolved_function_traits<Function>;
+    parsed_arguments parsed = parser_.parse(argc, argv);
+    return invoke_with_args(parsed, std::make_index_sequence<traits::arity>{});
+  }
+
+  [[nodiscard]] std::string signature() const override {
+    return std::string(type_name<Function>());
+  }
+
+  [[nodiscard]] bool accepts_arity(int argc) const noexcept override {
+    using traits = resolved_function_traits<Function>;
+    if (has_rest_args(std::make_index_sequence<traits::arity>{})) {
+      return true;
+    }
+    if (parser_.configured() || has_special_args(std::make_index_sequence<traits::arity>{})) {
+      return argc <= static_cast<int>(traits::arity + 1U);
+    }
+    return argc == static_cast<int>(traits::arity);
+  }
+
+  [[nodiscard]] int match_score(int argc, const VALUE* argv) const noexcept override {
+    using traits = resolved_function_traits<Function>;
+    using args = typename traits::args_tuple;
+    if (parser_.configured() || has_special_args(std::make_index_sequence<traits::arity>{})) {
+      return accepts_arity(argc) ? 0 : -1;
+    }
+    return tuple_match_score<args>(argc, argv, std::make_index_sequence<traits::arity>{});
+  }
+
+  [[nodiscard]] std::size_t declared_arity() const noexcept override {
+    return resolved_function_traits<Function>::arity;
+  }
+
+private:
+  template <std::size_t... Index>
+  [[nodiscard]] value invoke_with_args(const parsed_arguments& parsed,
+                                       std::index_sequence<Index...>) {
+    using traits = resolved_function_traits<Function>;
+    using args = typename traits::args_tuple;
+    auto converted = std::tuple<decltype(load_parsed_argument<std::tuple_element_t<Index, args>>(
+        parsed, Index))...>{
+        load_parsed_argument<std::tuple_element_t<Index, args>>(parsed, Index)...};
+
+    if constexpr (std::is_void_v<typename traits::return_type>) {
+      std::apply(function_, converted);
+      return value{Qnil};
+    } else {
+      decltype(auto) result = std::apply(function_, converted);
+      return dump_result(std::forward<decltype(result)>(result), policy::kind::automatic);
+    }
+  }
+
+  template <std::size_t... Index>
+  static consteval bool has_special_args(std::index_sequence<Index...>) {
+    using args = typename resolved_function_traits<Function>::args_tuple;
+    return (is_special_argument_v<std::tuple_element_t<Index, args>> || ...);
+  }
+
+  template <std::size_t... Index>
+  static consteval bool has_rest_args(std::index_sequence<Index...>) {
+    using args = typename resolved_function_traits<Function>::args_tuple;
+    return (is_rest_argument_v<std::tuple_element_t<Index, args>> || ...);
+  }
+
+  Function function_;
+  argument_parser<typename resolved_function_traits<Function>::args_tuple> parser_;
+};
+
+template <typename Result> value dump_result(Result&& result, policy::kind selected) {
+  using result_type = Result;
+  using bare_type = std::remove_cvref_t<Result>;
+  if constexpr (std::is_pointer_v<bare_type> && std::is_class_v<std::remove_pointer_t<bare_type>>) {
+    using pointee = std::remove_pointer_t<bare_type>;
+    if (result == nullptr) {
+      return value{Qnil};
+    }
+    if (selected == policy::kind::copy) {
+      return wrap_copy(*result);
+    }
+    if (selected == policy::kind::take) {
+      return wrap_take(std::unique_ptr<pointee>{result});
+    }
+    if (selected == policy::kind::shared) {
+      throw std::invalid_argument("rbxx: shared policy requires std::shared_ptr<T>");
+    }
+    return wrap_reference(result);
+  } else if constexpr (std::is_lvalue_reference_v<result_type> && std::is_class_v<bare_type>) {
+    if (selected == policy::kind::copy) {
+      return wrap_copy(result);
+    }
+    if (selected == policy::kind::take || selected == policy::kind::shared) {
+      throw std::invalid_argument("rbxx: take/shared policy cannot be used with a reference");
+    }
+    return wrap_reference(std::addressof(result));
+  } else {
+    return to_ruby(std::forward<Result>(result));
+  }
+}
+
+struct method_key {
+  VALUE owner;
+  ID method;
+
+  friend bool operator==(const method_key&, const method_key&) = default;
+};
+
+struct method_key_hash {
+  [[nodiscard]] std::size_t operator()(const method_key& key) const noexcept {
+    const auto owner = static_cast<std::size_t>(key.owner);
+    const auto method = static_cast<std::size_t>(key.method);
+    return owner ^ (method + 0x9e3779b9U + (owner << 6U) + (owner >> 2U));
+  }
+};
+
+class method_registry {
+public:
+  static method_registry& instance() {
+    static auto* registry = new method_registry();
+    return *registry;
+  }
+
+  bool add(VALUE owner, ID method, std::unique_ptr<native_function> function) {
+    std::lock_guard lock(write_mutex_);
+    auto& overloads = functions_[method_key{owner, method}];
+    const bool first = overloads.empty();
+    overloads.push_back(std::move(function));
+    return first;
+  }
+
+  using overloads = std::vector<std::unique_ptr<native_function>>;
+
+  [[nodiscard]] const overloads* find(VALUE self, ID method) const noexcept {
+    if (const auto* direct = find_exact(self, method)) {
+      return direct;
+    }
+
+    VALUE klass = CLASS_OF(self);
+    while (!NIL_P(klass)) {
+      if (const auto* inherited = find_exact(klass, method)) {
+        return inherited;
+      }
+      klass = rb_class_superclass(klass);
+    }
+    return find_exact(Qnil, method);
+  }
+
+private:
+  [[nodiscard]] const overloads* find_exact(VALUE owner, ID method) const noexcept {
+    auto found = functions_.find(method_key{owner, method});
+    return found == functions_.end() ? nullptr : std::addressof(found->second);
+  }
+
+  std::mutex write_mutex_;
+  std::unordered_map<method_key, overloads, method_key_hash> functions_;
+};
+
+inline VALUE function_trampoline(int argc, VALUE* argv, VALUE self) {
+  VALUE pending = Qnil;
+  VALUE result = Qnil;
+  try {
+    ID method = rb_frame_this_func();
+    const auto* functions = method_registry::instance().find(self, method);
+    if (functions == nullptr || functions->empty()) {
+      throw std::runtime_error("rbxx: native function registry entry was not found");
+    }
+    native_function* selected = nullptr;
+    int best_score = -1;
+    for (const auto& candidate : *functions) {
+      int score = candidate->match_score(argc, argv);
+      if (score > best_score) {
+        best_score = score;
+        selected = candidate.get();
+      }
+    }
+    if (selected == nullptr && functions->size() == 1U && functions->front()->accepts_arity(argc)) {
+      selected = functions->front().get();
+    }
+    if (selected == nullptr) {
+      std::string message = "rbxx: no matching overload";
+      if (functions->size() == 1U) {
+        message += "; expected ";
+        message += std::to_string(functions->front()->declared_arity());
+        message += ", actual ";
+        message += std::to_string(argc);
+      }
+      message += "; candidates:";
+      for (const auto& candidate : *functions) {
+        message += "\n  ";
+        message += candidate->signature();
+      }
+      throw ruby_error(make_exception(rb_eArgError, message.c_str()));
+    }
+    result = selected->invoke(argc, argv, value{self}).raw();
+  } catch (...) {
+    pending = translate_current_exception();
+  }
+  if (!NIL_P(pending)) {
+    rb_exc_raise(pending);
+  }
+  return result;
+}
+
+template <typename Function>
+void register_function(VALUE owner, const char* name, Function&& function,
+                       std::vector<argument_spec> specs = {}, bool global = false) {
+  using stored_function = std::decay_t<Function>;
+  if constexpr (!function_signature<stored_function>) {
+    static_assert(
+        function_signature<stored_function>,
+        "rbxx: callable signature cannot be determined; use a non-generic lambda, function "
+        "pointer, or std::function");
+  } else if constexpr (!function_arguments_convertible<stored_function>()) {
+    static_assert(
+        function_arguments_convertible<stored_function>(),
+        "rbxx: function argument type has no type_caster; bind the type with def_class<T>() "
+        "or specialize rbxx::type_caster<T>");
+  } else if constexpr (!function_return_convertible<stored_function>()) {
+    static_assert(
+        function_return_convertible<stored_function>(),
+        "rbxx: function return type has no type_caster; bind the type with def_class<T>() "
+        "or specialize rbxx::type_caster<T>");
+  } else {
+    ID method = protect(rb_intern, name);
+    const bool first =
+        method_registry::instance().add(global ? Qnil : owner, method,
+                                        std::make_unique<native_function_impl<stored_function>>(
+                                            std::forward<Function>(function), std::move(specs)));
+    if (first) {
+      protect([owner, name, global] {
+        if (global) {
+          rb_define_global_function(name, function_trampoline, -1);
+        } else {
+          rb_define_module_function(owner, name, function_trampoline, -1);
+        }
+      });
+    }
+  }
+}
+
+template <typename Function>
+void register_static_function(VALUE owner, const char* name, Function&& function,
+                              std::vector<argument_spec> specs = {}) {
+  using stored_function = std::decay_t<Function>;
+  if constexpr (!function_signature<stored_function>) {
+    static_assert(
+        function_signature<stored_function>,
+        "rbxx: callable signature cannot be determined; use a non-generic lambda, function "
+        "pointer, or std::function");
+  } else if constexpr (!function_arguments_convertible<stored_function>()) {
+    static_assert(function_arguments_convertible<stored_function>(),
+                  "rbxx: function argument type has no type_caster");
+  } else if constexpr (!function_return_convertible<stored_function>()) {
+    static_assert(function_return_convertible<stored_function>(),
+                  "rbxx: function return type has no type_caster");
+  } else {
+    ID method = protect(rb_intern, name);
+    const bool first =
+        method_registry::instance().add(owner, method,
+                                        std::make_unique<native_function_impl<stored_function>>(
+                                            std::forward<Function>(function), std::move(specs)));
+    if (first) {
+      protect([owner, name] { rb_define_singleton_method(owner, name, function_trampoline, -1); });
+    }
+  }
+}
+
+} // namespace rbxx::detail
+// END rbxx/function.hpp
+
+// BEGIN rbxx/operators.hpp
+
+namespace rbxx::op {
+
+/// @brief Metadata for mapping a C++ callable to a Ruby operator method.
+struct name {
+  const char* ruby_name;
+  bool include_comparable = false;
+};
+
+/// @name Ruby operator names
+/// @{
+inline constexpr name add{"+"};
+inline constexpr name subtract{"-"};
+inline constexpr name multiply{"*"};
+inline constexpr name divide{"/"};
+inline constexpr name modulo{"%"};
+inline constexpr name equal{"=="};
+inline constexpr name compare{"<=>", true};
+inline constexpr name less{"<"};
+inline constexpr name greater{">"};
+inline constexpr name index{"[]"};
+inline constexpr name index_set{"[]="};
+inline constexpr name left_shift{"<<"};
+inline constexpr name to_s{"to_s"};
+inline constexpr name inspect{"inspect"};
+inline constexpr name hash{"hash"};
+inline constexpr name call{"call"};
+/// @}
+
+} // namespace rbxx::op
+// END rbxx/operators.hpp
+
+// BEGIN rbxx/module.hpp
+
+
+#include <source_location>
+#include <utility>
+
+namespace rbxx {
+
+template <typename T> class class_;
+
+/// @brief A non-owning DSL handle for a Ruby Module.
+/// @code rbxx::define_module("Demo").def("answer", [] { return 42; }); @endcode
+class module {
+public:
+  /// @brief Wraps an existing Ruby module VALUE.
+  explicit module(value wrapped) noexcept : wrapped_(wrapped) {}
+
+  /// @brief Returns the wrapped Ruby module.
+  [[nodiscard]] value get() const noexcept { return wrapped_; }
+
+  /// @brief Defines a Ruby module function backed by a C++ callable.
+  /// @code mod.def("sum", [](int a, int b) { return a + b; }); @endcode
+  template <typename Function, typename... Specs>
+  module& def(const char* name, Function&& function, Specs&&... specs) {
+    using traits = detail::resolved_function_traits<std::decay_t<Function>>;
+    if constexpr (detail::function_signature<std::decay_t<Function>>) {
+      static_assert(sizeof...(Specs) == 0U ||
+                        sizeof...(Specs) ==
+                            detail::normal_argument_count<typename traits::args_tuple>(),
+                    "rbxx: argument annotation count must match callable parameters");
+    }
+    detail::register_function(wrapped_.raw(), name, std::forward<Function>(function),
+                              detail::make_argument_specs(std::forward<Specs>(specs)...));
+    return *this;
+  }
+
+  template <typename Function, typename... Specs>
+  module& def(op::name operation, Function&& function, Specs&&... specs) {
+    return def(operation.ruby_name, std::forward<Function>(function),
+               std::forward<Specs>(specs)...);
+  }
+
+  /// @brief Defines a Ruby class backed by CRuby TypedData.
+  /// @code auto counter = mod.def_class<Counter>("Counter"); @endcode
+  template <typename T, typename Base = void>
+  class_<T> def_class(const char* name,
+                      std::source_location location = std::source_location::current());
+
+private:
+  value wrapped_;
+};
+
+/// @brief Defines or reopens a top-level Ruby module.
+/// @code rbxx::module demo = rbxx::define_module("Demo"); @endcode
+[[nodiscard]] inline module define_module(const char* name) {
+  return module{value{protect(rb_define_module, name)}};
+}
+
+/// @brief Defines a private Kernel method callable as a Ruby global function.
+/// @code rbxx::define_global_function("native_sum", [](int a, int b) { return a + b; }); @endcode
+template <typename Function, typename... Specs>
+void define_global_function(const char* name, Function&& function, Specs&&... specs) {
+  detail::register_function(Qnil, name, std::forward<Function>(function),
+                            detail::make_argument_specs(std::forward<Specs>(specs)...), true);
+}
+
+} // namespace rbxx
+// END rbxx/module.hpp
+
+// BEGIN rbxx/class.hpp
+
+
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+
+/// @brief Constructor signature marker used by class_::def.
+/// @code binding.def(rbxx::init<int>()); @endcode
+template <typename... Args> struct init_tag {};
+
+/// @brief Creates a constructor signature marker.
+template <typename... Args> [[nodiscard]] constexpr init_tag<Args...> init() noexcept { return {}; }
+
+namespace detail {
+
+template <typename Method> struct member_method_traits;
+
+template <typename Class, typename Return, typename... Args>
+struct member_method_traits<Return (Class::*)(Args...)> : function_traits<Return(Args...)> {
+  using class_type = Class;
+};
+
+template <typename Class, typename Return, typename... Args>
+struct member_method_traits<Return (Class::*)(Args...) const> : function_traits<Return(Args...)> {
+  using class_type = Class;
+};
+
+template <typename Class, typename Return, typename... Args>
+struct member_method_traits<Return (Class::*)(Args...) noexcept>
+    : function_traits<Return(Args...)> {
+  using class_type = Class;
+};
+
+template <typename Class, typename Return, typename... Args>
+struct member_method_traits<Return (Class::*)(Args...) const noexcept>
+    : function_traits<Return(Args...)> {
+  using class_type = Class;
+};
+
+inline void define_instance_trampoline(VALUE klass, const char* name) {
+  protect([klass, name] { rb_define_method(klass, name, function_trampoline, -1); });
+}
+
+struct fast_zero_slot {
+  VALUE (*invoke)(void*, VALUE);
+  void* context;
+};
+
+inline constexpr std::size_t fast_zero_slot_count = 64U;
+
+inline std::array<fast_zero_slot, fast_zero_slot_count>& fast_zero_slots() {
+  static auto* slots = new std::array<fast_zero_slot, fast_zero_slot_count>{};
+  return *slots;
+}
+
+template <std::size_t Index> VALUE fast_zero_trampoline(VALUE self) {
+  VALUE result = Qnil;
+  VALUE pending = Qnil;
+  try {
+    const fast_zero_slot& slot = fast_zero_slots()[Index];
+    result = slot.invoke(slot.context, self);
+  } catch (...) {
+    pending = translate_current_exception();
+  }
+  if (!NIL_P(pending)) {
+    rb_exc_raise(pending);
+  }
+  return result;
+}
+
+using fast_zero_method = VALUE (*)(VALUE);
+
+template <std::size_t Index = 0U> fast_zero_method select_fast_zero_method(std::size_t selected) {
+  if constexpr (Index < fast_zero_slot_count) {
+    if (selected == Index) {
+      return &fast_zero_trampoline<Index>;
+    }
+    return select_fast_zero_method<Index + 1U>(selected);
+  }
+  return nullptr;
+}
+
+inline std::optional<std::size_t> add_fast_zero_slot(fast_zero_slot slot) {
+  static std::size_t next = 0U;
+  if (next == fast_zero_slot_count) {
+    return std::nullopt;
+  }
+  const std::size_t selected = next++;
+  fast_zero_slots()[selected] = slot;
+  return selected;
+}
+
+template <typename Bound> Bound& load_bound_fast(VALUE self) {
+  if (RB_TYPE_P(self, T_DATA) && RTYPEDDATA_P(self) &&
+      RTYPEDDATA_TYPE(self) == &typed_data_type<Bound>()) {
+    auto& wrapper = *static_cast<data_wrapper<Bound>*>(RTYPEDDATA_DATA(self));
+    if (wrapper.pointer == nullptr) {
+      throw ruby_error(make_exception(rb_eRuntimeError, "rbxx: C++ object is not initialized"));
+    }
+    return *wrapper.pointer;
+  }
+  return load_registered<Bound>(value{self});
+}
+
+template <typename Bound, typename Method> struct fast_member_context {
+  Method method;
+  policy::kind selected;
+};
+
+template <typename Bound, typename Method> VALUE invoke_fast_member(void* opaque, VALUE self) {
+  auto& context = *static_cast<fast_member_context<Bound, Method>*>(opaque);
+  Bound& native = load_bound_fast<Bound>(self);
+  using traits = member_method_traits<Method>;
+  if constexpr (std::is_void_v<typename traits::return_type>) {
+    std::invoke(context.method, native);
+    return Qnil;
+  } else {
+    decltype(auto) result = std::invoke(context.method, native);
+    return dump_result(std::forward<decltype(result)>(result), context.selected).raw();
+  }
+}
+
+template <typename Bound, typename Method>
+bool define_fast_member(VALUE klass, const char* name, Method method, policy::kind selected) {
+  auto context = std::make_unique<fast_member_context<Bound, Method>>(method, selected);
+  const auto slot =
+      add_fast_zero_slot(fast_zero_slot{&invoke_fast_member<Bound, Method>, context.get()});
+  if (!slot) {
+    return false;
+  }
+  fast_zero_method trampoline = select_fast_zero_method(*slot);
+  protect([klass, name, trampoline] { rb_define_method(klass, name, trampoline, 0); });
+  context.release();
+  return true;
+}
+
+template <typename Bound, auto Method> VALUE direct_member_trampoline(VALUE self) {
+  VALUE result = Qnil;
+  VALUE pending = Qnil;
+  try {
+    Bound& native = load_bound_fast<Bound>(self);
+    using traits = member_method_traits<decltype(Method)>;
+    if constexpr (std::is_void_v<typename traits::return_type>) {
+      std::invoke(Method, native);
+    } else {
+      decltype(auto) native_result = std::invoke(Method, native);
+      result =
+          dump_result(std::forward<decltype(native_result)>(native_result), policy::kind::automatic)
+              .raw();
+    }
+  } catch (...) {
+    pending = translate_current_exception();
+  }
+  if (!NIL_P(pending)) {
+    rb_exc_raise(pending);
+  }
+  return result;
+}
+
+template <typename Bound, auto Method> void define_direct_member(VALUE klass, const char* name) {
+  constexpr fast_zero_method trampoline = &direct_member_trampoline<Bound, Method>;
+  protect([klass, name] { rb_define_method(klass, name, trampoline, 0); });
+}
+
+template <typename T, typename... Args> class constructor_function final : public native_function {
+public:
+  explicit constructor_function(std::vector<argument_spec> specs = {})
+      : parser_(std::move(specs)) {}
+
+  [[nodiscard]] value invoke(int argc, const VALUE* argv, value self) override {
+    parsed_arguments parsed = parser_.parse(argc, argv);
+    auto converted = load(parsed, std::index_sequence_for<Args...>{});
+    auto& wrapper = exact_wrapper<T>(self);
+    if (wrapper.pointer != nullptr) {
+      throw ruby_error(make_exception(rb_eRuntimeError, "rbxx: C++ object is already initialized"));
+    }
+    wrapper.pointer = std::apply(
+        [](auto&&... arguments) { return new T(std::forward<decltype(arguments)>(arguments)...); },
+        converted);
+    wrapper.mode = ownership::owned;
+    return value{Qnil};
+  }
+
+  [[nodiscard]] std::string signature() const override {
+    return "init<" + std::string(type_name<T>()) + ">";
+  }
+
+  [[nodiscard]] bool accepts_arity(int argc) const noexcept override {
+    return parser_.configured() ? argc <= static_cast<int>(sizeof...(Args) + 1U)
+                                : argc == static_cast<int>(sizeof...(Args));
+  }
+
+  [[nodiscard]] int match_score(int argc, const VALUE* argv) const noexcept override {
+    if (parser_.configured()) {
+      return accepts_arity(argc) ? 0 : -1;
+    }
+    using tuple = std::tuple<Args...>;
+    return tuple_match_score<tuple>(argc, argv, std::index_sequence_for<Args...>{});
+  }
+
+  [[nodiscard]] std::size_t declared_arity() const noexcept override { return sizeof...(Args); }
+
+private:
+  template <std::size_t... Index>
+  static auto load(const parsed_arguments& parsed, std::index_sequence<Index...>) {
+    return std::tuple<decltype(load_parsed_argument<Args>(parsed, Index))...>{
+        load_parsed_argument<Args>(parsed, Index)...};
+  }
+
+  argument_parser<std::tuple<Args...>> parser_;
+};
+
+template <typename Bound, typename Method> class member_function final : public native_function {
+public:
+  member_function(Method method, policy::kind selected, std::vector<argument_spec> specs = {},
+                  std::vector<keep_alive_spec> keep_alive = {})
+      : method_(method), policy_(selected), parser_(std::move(specs)),
+        keep_alive_(std::move(keep_alive)) {}
+
+  [[nodiscard]] value invoke(int argc, const VALUE* argv, value self) override {
+    using traits = member_method_traits<Method>;
+    parsed_arguments parsed = parser_.parse(argc, argv);
+    Bound& native = load_registered<Bound>(self);
+    value result = invoke_native(native, parsed, std::make_index_sequence<traits::arity>{});
+    apply_keep_alive(keep_alive_, result, self, argc, argv);
+    return result;
+  }
+
+  [[nodiscard]] std::string signature() const override { return std::string(type_name<Method>()); }
+
+  [[nodiscard]] bool accepts_arity(int argc) const noexcept override {
+    constexpr auto arity = member_method_traits<Method>::arity;
+    return parser_.configured() ? argc <= static_cast<int>(arity + 1U)
+                                : argc == static_cast<int>(arity);
+  }
+
+  [[nodiscard]] int match_score(int argc, const VALUE* argv) const noexcept override {
+    using traits = member_method_traits<Method>;
+    if (parser_.configured()) {
+      return accepts_arity(argc) ? 0 : -1;
+    }
+    return tuple_match_score<typename traits::args_tuple>(
+        argc, argv, std::make_index_sequence<traits::arity>{});
+  }
+
+  [[nodiscard]] std::size_t declared_arity() const noexcept override {
+    return member_method_traits<Method>::arity;
+  }
+
+private:
+  template <std::size_t... Index>
+  [[nodiscard]] value invoke_native(Bound& self, const parsed_arguments& parsed,
+                                    std::index_sequence<Index...>) {
+    using traits = member_method_traits<Method>;
+    using args = typename traits::args_tuple;
+    auto converted = std::tuple<decltype(load_parsed_argument<std::tuple_element_t<Index, args>>(
+        parsed, Index))...>{
+        load_parsed_argument<std::tuple_element_t<Index, args>>(parsed, Index)...};
+    if constexpr (std::is_void_v<typename traits::return_type>) {
+      std::apply([&](auto&&... values) { std::invoke(method_, self, values...); }, converted);
+      return value{Qnil};
+    } else {
+      decltype(auto) result = std::apply(
+          [&](auto&&... values) -> decltype(auto) { return std::invoke(method_, self, values...); },
+          converted);
+      return dump_result(std::forward<decltype(result)>(result), policy_);
+    }
+  }
+
+  Method method_;
+  policy::kind policy_;
+  argument_parser<typename member_method_traits<Method>::args_tuple> parser_;
+  std::vector<keep_alive_spec> keep_alive_;
+};
+
+template <typename Tuple, std::size_t... Index>
+consteval bool self_arguments_convertible(std::index_sequence<Index...>) {
+  return (from_ruby_convertible<std::tuple_element_t<Index + 1U, Tuple>> && ...);
+}
+
+template <typename Tuple, std::size_t... Index>
+auto tuple_tail_type(std::index_sequence<Index...>)
+    -> std::tuple<std::tuple_element_t<Index + 1U, Tuple>...>;
+
+template <typename Tuple>
+using tuple_tail_t =
+    decltype(tuple_tail_type<Tuple>(std::make_index_sequence<std::tuple_size_v<Tuple> - 1U>{}));
+
+template <typename Bound, typename Function> class self_function final : public native_function {
+public:
+  using traits = resolved_function_traits<Function>;
+  using args = typename traits::args_tuple;
+  static constexpr std::size_t ruby_arity = traits::arity - 1U;
+
+  self_function(Function function, policy::kind selected, std::vector<argument_spec> specs = {},
+                std::vector<keep_alive_spec> keep_alive = {})
+      : function_(std::move(function)), policy_(selected), parser_(std::move(specs)),
+        keep_alive_(std::move(keep_alive)) {
+    static_assert(traits::arity > 0,
+                  "rbxx: instance lambda must accept self as its first argument");
+    using self_argument = std::tuple_element_t<0, args>;
+    static_assert(std::is_lvalue_reference_v<self_argument> &&
+                      std::is_same_v<std::remove_cvref_t<self_argument>, Bound>,
+                  "rbxx: instance lambda first argument must be T& or const T&");
+    static_assert(self_arguments_convertible<args>(std::make_index_sequence<ruby_arity>{}),
+                  "rbxx: instance lambda argument type has no type_caster");
+  }
+
+  [[nodiscard]] value invoke(int argc, const VALUE* argv, value self) override {
+    parsed_arguments parsed = parser_.parse(argc, argv);
+    Bound& native = load_registered<Bound>(self);
+    value result = invoke_native(native, parsed, std::make_index_sequence<ruby_arity>{});
+    apply_keep_alive(keep_alive_, result, self, argc, argv);
+    return result;
+  }
+
+  [[nodiscard]] std::string signature() const override {
+    return std::string(type_name<Function>());
+  }
+  [[nodiscard]] bool accepts_arity(int argc) const noexcept override {
+    return parser_.configured() ? argc <= static_cast<int>(ruby_arity + 1U)
+                                : argc == static_cast<int>(ruby_arity);
+  }
+  [[nodiscard]] int match_score(int argc, const VALUE* argv) const noexcept override {
+    if (parser_.configured()) {
+      return accepts_arity(argc) ? 0 : -1;
+    }
+    using ruby_args = tuple_tail_t<args>;
+    return tuple_match_score<ruby_args>(argc, argv, std::make_index_sequence<ruby_arity>{});
+  }
+  [[nodiscard]] std::size_t declared_arity() const noexcept override { return ruby_arity; }
+
+private:
+  template <std::size_t... Index>
+  [[nodiscard]] value invoke_native(Bound& self, const parsed_arguments& parsed,
+                                    std::index_sequence<Index...>) {
+    auto converted =
+        std::tuple<decltype(load_parsed_argument<std::tuple_element_t<Index + 1U, args>>(
+            parsed, Index))...>{
+            load_parsed_argument<std::tuple_element_t<Index + 1U, args>>(parsed, Index)...};
+    if constexpr (std::is_void_v<typename traits::return_type>) {
+      std::apply([&](auto&&... values) { std::invoke(function_, self, values...); }, converted);
+      return value{Qnil};
+    } else {
+      decltype(auto) result = std::apply(
+          [&](auto&&... values) -> decltype(auto) {
+            return std::invoke(function_, self, values...);
+          },
+          converted);
+      return dump_result(std::forward<decltype(result)>(result), policy_);
+    }
+  }
+
+  Function function_;
+  policy::kind policy_;
+  argument_parser<tuple_tail_t<args>> parser_;
+  std::vector<keep_alive_spec> keep_alive_;
+};
+
+template <typename Bound, auto Begin, auto End>
+class iterable_function final : public native_function {
+public:
+  [[nodiscard]] value invoke(int, const VALUE*, value self) override {
+    if (rb_block_given_p() == 0) {
+      VALUE enumerator = protect([self] {
+        return rb_enumeratorize_with_size(self.raw(), ID2SYM(rb_intern("each")), 0, nullptr,
+                                          size_callback);
+      });
+      return value{enumerator};
+    }
+
+    Bound& native = load_registered<Bound>(self);
+    auto iterator = std::invoke(Begin, native);
+    const auto finish = std::invoke(End, native);
+    for (; iterator != finish; ++iterator) {
+      value item = to_ruby(*iterator);
+      protect(rb_yield, item.raw());
+    }
+    return self;
+  }
+
+  [[nodiscard]] std::string signature() const override { return "each()"; }
+  [[nodiscard]] bool accepts_arity(int argc) const noexcept override { return argc == 0; }
+  [[nodiscard]] int match_score(int argc, const VALUE*) const noexcept override {
+    return argc == 0 ? 0 : -1;
+  }
+  [[nodiscard]] std::size_t declared_arity() const noexcept override { return 0U; }
+
+private:
+  static VALUE size_callback(VALUE self, VALUE, VALUE) {
+    VALUE result = Qnil;
+    VALUE pending = Qnil;
+    try {
+      Bound& native = load_registered<Bound>(value{self});
+      auto first = std::invoke(Begin, native);
+      auto last = std::invoke(End, native);
+      result = to_ruby(std::distance(first, last)).raw();
+    } catch (...) {
+      pending = translate_current_exception();
+    }
+    if (!NIL_P(pending)) {
+      rb_exc_raise(pending);
+    }
+    return result;
+  }
+};
+
+} // namespace detail
+
+/// @brief Fluent binding handle for a C++ class exposed as Ruby TypedData.
+/// @code binding.def(rbxx::init<int>()).def("value", &Counter::value); @endcode
+template <typename T> class class_ {
+public:
+  explicit class_(value ruby_class) noexcept : ruby_class_(ruby_class) {}
+
+  [[nodiscard]] value get() const noexcept { return ruby_class_; }
+
+  /// @brief Defines a compile-time-bound zero-argument member on the minimal dispatch path.
+  /// @code binding.def<&Counter::value>("value"); @endcode
+  template <auto Method> class_& def(const char* name) {
+    using method_type = decltype(Method);
+    static_assert(std::is_member_function_pointer_v<method_type>,
+                  "rbxx: compile-time def requires a member function pointer");
+    using traits = detail::member_method_traits<method_type>;
+    static_assert(traits::arity == 0U,
+                  "rbxx: compile-time def currently supports zero-argument members");
+    static_assert(std::is_void_v<typename traits::return_type> ||
+                      to_ruby_convertible<typename traits::return_type>,
+                  "rbxx: member function return type has no type_caster");
+
+    ID method = protect(rb_intern, name);
+    const bool first = detail::method_registry::instance().add(
+        ruby_class_.raw(), method,
+        std::make_unique<detail::member_function<T, method_type>>(Method, policy::kind::automatic));
+    if (first) {
+      detail::define_direct_member<T, Method>(ruby_class_.raw(), name);
+    } else {
+      detail::define_instance_trampoline(ruby_class_.raw(), name);
+    }
+    return *this;
+  }
+
+  /// @brief Defines a C++ constructor and optional Ruby argument annotations.
+  template <typename... Args, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(init_tag<Args...>, Specs&&... specs) {
+    static_assert(sizeof...(Specs) == 0U ||
+                      sizeof...(Specs) == detail::normal_argument_count<std::tuple<Args...>>(),
+                  "rbxx: argument annotation count must match constructor parameters");
+    static_assert((from_ruby_convertible<Args> && ...),
+                  "rbxx: constructor argument type has no type_caster");
+    ID method = protect(rb_intern, "initialize");
+    const bool first = detail::method_registry::instance().add(
+        ruby_class_.raw(), method,
+        std::make_unique<detail::constructor_function<T, Args...>>(
+            detail::make_argument_specs(std::forward<Specs>(specs)...)));
+    if (first) {
+      detail::define_instance_trampoline(ruby_class_.raw(), "initialize");
+    }
+    return *this;
+  }
+
+  /// @brief Defines an instance method backed by a member pointer or self-first callable.
+  template <typename Function, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(const char* name, Function&& function, Specs&&... specs) {
+    return bind_function(name, std::forward<Function>(function), policy::automatic,
+                         detail::make_argument_specs(std::forward<Specs>(specs)...));
+  }
+
+  template <typename Function, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(const char* name, Function&& function, policy::return_value_policy selected,
+              Specs&&... specs) {
+    return bind_function(name, std::forward<Function>(function), selected,
+                         detail::make_argument_specs(std::forward<Specs>(specs)...));
+  }
+
+  template <typename Function, std::size_t Nurse, std::size_t Patient, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(const char* name, Function&& function, policy::return_value_policy selected,
+              keep_alive<Nurse, Patient> lifetime, Specs&&... specs) {
+    return bind_function(name, std::forward<Function>(function), selected,
+                         detail::make_argument_specs(std::forward<Specs>(specs)...),
+                         {detail::make_keep_alive_spec(lifetime)});
+  }
+
+  template <typename Function, std::size_t Nurse, std::size_t Patient, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(const char* name, Function&& function, keep_alive<Nurse, Patient> lifetime,
+              Specs&&... specs) {
+    return bind_function(name, std::forward<Function>(function), policy::automatic,
+                         detail::make_argument_specs(std::forward<Specs>(specs)...),
+                         {detail::make_keep_alive_spec(lifetime)});
+  }
+
+  template <typename Function, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(op::name operation, Function&& function, Specs&&... specs) {
+    class_& result =
+        def(operation.ruby_name, std::forward<Function>(function), std::forward<Specs>(specs)...);
+    include_comparable(operation);
+    return result;
+  }
+
+  template <typename Function, typename... Specs>
+    requires((std::is_convertible_v<Specs, argument_spec>) && ...)
+  class_& def(op::name operation, Function&& function, policy::return_value_policy selected,
+              Specs&&... specs) {
+    class_& result = def(operation.ruby_name, std::forward<Function>(function), selected,
+                         std::forward<Specs>(specs)...);
+    include_comparable(operation);
+    return result;
+  }
+
+  /// @brief Defines a singleton method on the bound Ruby class.
+  template <typename Function, typename... Specs>
+  class_& def_static(const char* name, Function&& function, Specs&&... specs) {
+    detail::register_static_function(ruby_class_.raw(), name, std::forward<Function>(function),
+                                     detail::make_argument_specs(std::forward<Specs>(specs)...));
+    return *this;
+  }
+
+  /// @brief Defines a Ruby reader for a public C++ data member.
+  template <typename Member> class_& def_attr_reader(const char* name, Member T::*member) {
+    return def(name, [member](const T& self) -> const Member& { return self.*member; });
+  }
+
+  /// @brief Defines a Ruby writer for a public C++ data member.
+  template <typename Member> class_& def_attr_writer(const char* name, Member T::*member) {
+    std::string writer = std::string(name) + "=";
+    return def(writer.c_str(), [member](T& self, Member updated) {
+      self.*member = std::move(updated);
+      return self.*member;
+    });
+  }
+
+  /// @brief Defines Ruby reader and writer methods for a public C++ data member.
+  template <typename Member> class_& def_attr_accessor(const char* name, Member T::*member) {
+    def_attr_reader(name, member);
+    return def_attr_writer(name, member);
+  }
+
+  /// @brief Defines Ruby each, includes Enumerable, and returns sized enumerators without a block.
+  template <auto Begin, auto End> class_& def_iterable() {
+    using item_reference = decltype(*std::invoke(Begin, std::declval<T&>()));
+    static_assert(to_ruby_convertible<item_reference>,
+                  "rbxx: iterable item type has no type_caster");
+    ID method = protect(rb_intern, "each");
+    const bool first = detail::method_registry::instance().add(
+        ruby_class_.raw(), method, std::make_unique<detail::iterable_function<T, Begin, End>>());
+    if (first) {
+      detail::define_instance_trampoline(ruby_class_.raw(), "each");
+    }
+    protect(rb_include_module, ruby_class_.raw(), rb_mEnumerable);
+    return *this;
+  }
+
+private:
+  void include_comparable(op::name operation) {
+    if (operation.include_comparable) {
+      protect(rb_include_module, ruby_class_.raw(), rb_mComparable);
+    }
+  }
+
+  template <typename Function>
+  class_& bind_function(const char* name, Function&& function, policy::return_value_policy selected,
+                        std::vector<argument_spec> specs,
+                        std::vector<detail::keep_alive_spec> keep_alive = {}) {
+    using stored_function = std::decay_t<Function>;
+    ID method = protect(rb_intern, name);
+    if constexpr (std::is_member_function_pointer_v<stored_function>) {
+      using traits = detail::member_method_traits<stored_function>;
+      static_assert(detail::arguments_convertible<typename traits::args_tuple>(
+                        std::make_index_sequence<traits::arity>{}),
+                    "rbxx: member function argument type has no type_caster");
+      const bool fast = traits::arity == 0U && specs.empty() && keep_alive.empty();
+      const bool first = detail::method_registry::instance().add(
+          ruby_class_.raw(), method,
+          std::make_unique<detail::member_function<T, stored_function>>(
+              function, selected.value, std::move(specs), std::move(keep_alive)));
+      bool defined_fast = false;
+      if constexpr (traits::arity == 0U) {
+        defined_fast =
+            first && fast &&
+            detail::define_fast_member<T>(ruby_class_.raw(), name, function, selected.value);
+      }
+      if (!defined_fast) {
+        detail::define_instance_trampoline(ruby_class_.raw(), name);
+      }
+    } else {
+      static_assert(detail::function_signature<stored_function>,
+                    "rbxx: instance callable signature cannot be determined");
+      detail::method_registry::instance().add(
+          ruby_class_.raw(), method,
+          std::make_unique<detail::self_function<T, stored_function>>(
+              std::forward<Function>(function), selected.value, std::move(specs),
+              std::move(keep_alive)));
+      detail::define_instance_trampoline(ruby_class_.raw(), name);
+    }
+    return *this;
+  }
+  value ruby_class_;
+};
+
+template <typename T, typename Base>
+class_<T> module::def_class(const char* name, std::source_location location) {
+  VALUE superclass = rb_cObject;
+  if constexpr (!std::is_void_v<Base>) {
+    static_assert(std::is_base_of_v<Base, T>, "rbxx: Base must be a C++ base class of T");
+    superclass = detail::registered_class<Base>().ruby_class;
+  }
+  VALUE klass = protect(rb_define_class_under, wrapped_.raw(), name, superclass);
+  detail::register_data_class<T, Base>(klass, location);
+  protect([klass] { rb_define_alloc_func(klass, detail::allocate_data_object<T>); });
+  return class_<T>{value{klass}};
+}
+
+} // namespace rbxx
+// END rbxx/class.hpp
+
+// BEGIN rbxx/extension.hpp
+
+
+#if defined(_WIN32)
+#define RBXX_EXPORT __declspec(dllexport)
+#else
+#define RBXX_EXPORT __attribute__((visibility("default")))
+#endif
+
+#define RBXX_EXTENSION(name)                                                                       \
+  static void rbxx_init_body_##name();                                                             \
+  extern "C" RBXX_EXPORT void Init_##name() {                                                      \
+    VALUE rbxx_pending_exception = Qnil;                                                           \
+    try {                                                                                          \
+      rbxx_init_body_##name();                                                                     \
+      return;                                                                                      \
+    } catch (...) {                                                                                \
+      rbxx_pending_exception = ::rbxx::detail::translate_current_exception();                      \
+    }                                                                                              \
+    rb_exc_raise(rbxx_pending_exception);                                                          \
+  }                                                                                                \
+  static void rbxx_init_body_##name()
+// END rbxx/extension.hpp
+
+// BEGIN rbxx/nogvl.hpp
+
+
+#include <exception>
+#include <functional>
+#include <optional>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+namespace detail {
+
+struct default_unblock_function {};
+
+template <typename T> struct is_std_function : std::false_type {};
+template <typename Return, typename... Args>
+struct is_std_function<std::function<Return(Args...)>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool gvl_independent_v = !std::is_same_v<std::remove_cvref_t<T>, value> &&
+                                          !std::is_same_v<std::remove_cvref_t<T>, object> &&
+                                          !std::is_same_v<std::remove_cvref_t<T>, block> &&
+                                          !std::is_same_v<std::remove_cvref_t<T>, optional_block> &&
+                                          !std::is_same_v<std::remove_cvref_t<T>, args> &&
+                                          !is_std_function<std::remove_cvref_t<T>>::value;
+
+template <typename Function, typename Unblock, typename Return, typename Tuple>
+class nogvl_adapter_impl;
+
+template <typename Function, typename Unblock, typename Return, typename... Args>
+class nogvl_adapter_impl<Function, Unblock, Return, std::tuple<Args...>> {
+public:
+  explicit nogvl_adapter_impl(Function function) : function_(std::move(function)) {
+    validate_signature();
+  }
+
+  nogvl_adapter_impl(Function function, Unblock unblock)
+      : function_(std::move(function)), unblock_(std::move(unblock)) {
+    validate_signature();
+    static_assert(std::is_nothrow_invocable_v<Unblock&>,
+                  "rbxx: nogvl interrupt function must be noexcept");
+  }
+
+  Return operator()(Args... args) {
+    payload work{this, std::tuple<Args...>{std::forward<Args>(args)...}, std::nullopt, nullptr};
+    if constexpr (std::is_same_v<Unblock, default_unblock_function>) {
+      protect([&work] { rb_thread_call_without_gvl(run, &work, RUBY_UBF_IO, nullptr); });
+    } else {
+      protect([&work, this] {
+        rb_thread_call_without_gvl(run, &work, interrupt, std::addressof(unblock_));
+      });
+    }
+    if (work.exception) {
+      std::rethrow_exception(work.exception);
+    }
+    if constexpr (!std::is_void_v<Return>) {
+      if (!work.result) {
+        throw std::runtime_error("rbxx: nogvl function was interrupted before producing a result");
+      }
+      return std::move(*work.result);
+    }
+  }
+
+private:
+  using stored_result = std::conditional_t<std::is_void_v<Return>, bool, Return>;
+
+  struct payload {
+    nogvl_adapter_impl* adapter;
+    std::tuple<Args...> arguments;
+    std::optional<stored_result> result;
+    std::exception_ptr exception;
+  };
+
+  static consteval void validate_signature() {
+    static_assert(!std::is_reference_v<Return>,
+                  "rbxx: nogvl return values must be owned C++ values");
+    static_assert(gvl_independent_v<Return>,
+                  "rbxx: nogvl return type must not access Ruby without the GVL");
+    static_assert((gvl_independent_v<Args> && ...),
+                  "rbxx: nogvl arguments must not access Ruby without the GVL");
+  }
+
+  static void* run(void* opaque) noexcept {
+    auto* work = static_cast<payload*>(opaque);
+    try {
+      if constexpr (std::is_void_v<Return>) {
+        std::apply(
+            [&](auto&&... values) {
+              std::invoke(work->adapter->function_, std::forward<Args>(values)...);
+            },
+            work->arguments);
+        work->result.emplace(true);
+      } else {
+        work->result.emplace(std::apply(
+            [&](auto&&... values) -> Return {
+              return std::invoke(work->adapter->function_, std::forward<Args>(values)...);
+            },
+            work->arguments));
+      }
+    } catch (...) {
+      work->exception = std::current_exception();
+    }
+    return nullptr;
+  }
+
+  static void interrupt(void* opaque) noexcept { std::invoke(*static_cast<Unblock*>(opaque)); }
+
+  Function function_;
+  [[no_unique_address]] Unblock unblock_{};
+};
+
+template <typename Function, typename Unblock = default_unblock_function>
+using nogvl_adapter =
+    nogvl_adapter_impl<std::decay_t<Function>, std::decay_t<Unblock>,
+                       typename resolved_function_traits<std::decay_t<Function>>::return_type,
+                       typename resolved_function_traits<std::decay_t<Function>>::args_tuple>;
+
+} // namespace detail
+
+/// @brief Wraps a pure C++ callable so its execution occurs without the Ruby GVL.
+template <typename Function> [[nodiscard]] auto nogvl(Function&& function) {
+  using stored_function = std::decay_t<Function>;
+  static_assert(detail::function_signature<stored_function>,
+                "rbxx: nogvl requires a callable with a concrete signature");
+  static_assert(!std::is_member_function_pointer_v<stored_function>,
+                "rbxx: nogvl expects a free function or callable object");
+  return detail::nogvl_adapter<stored_function>{std::forward<Function>(function)};
+}
+
+/// @brief Wraps a pure C++ callable with a noexcept interruption hook.
+template <typename Function, typename Unblock>
+[[nodiscard]] auto nogvl_interruptible(Function&& function, Unblock&& unblock) {
+  using stored_function = std::decay_t<Function>;
+  using stored_unblock = std::decay_t<Unblock>;
+  static_assert(detail::function_signature<stored_function>,
+                "rbxx: nogvl_interruptible requires a callable with a concrete signature");
+  static_assert(!std::is_member_function_pointer_v<stored_function>,
+                "rbxx: nogvl_interruptible expects a free function or callable object");
+  return detail::nogvl_adapter<stored_function, stored_unblock>{std::forward<Function>(function),
+                                                                std::forward<Unblock>(unblock)};
+}
+
+} // namespace rbxx
+// END rbxx/nogvl.hpp
+
+// BEGIN rbxx/stl/detail.hpp
+
+
+#include <limits>
+#include <string>
+#include <type_traits>
+
+namespace rbxx::detail {
+
+inline VALUE coerce_array(value input) {
+  VALUE converted = protect(rb_check_array_type, input.raw());
+  if (NIL_P(converted)) {
+    throw_type_error("Array or object responding to #to_ary", input);
+  }
+  return converted;
+}
+
+inline VALUE coerce_hash(value input) {
+  VALUE converted = protect(rb_check_hash_type, input.raw());
+  if (NIL_P(converted)) {
+    throw_type_error("Hash or object responding to #to_hash", input);
+  }
+  return converted;
+}
+
+template <typename Range> value dump_array_range(const Range& input) {
+  const auto size = input.size();
+  if (size > static_cast<std::size_t>(std::numeric_limits<long>::max())) {
+    throw std::length_error("rbxx: container is too large for a Ruby Array");
+  }
+  return value{protect([&input, size] {
+    VALUE result = rb_ary_new_capa(static_cast<long>(size));
+    for (const auto& element : input) {
+      using element_type = std::remove_cvref_t<decltype(element)>;
+      if constexpr (std::is_floating_point_v<element_type>) {
+        rb_ary_push(result, rb_float_new(static_cast<double>(element)));
+      } else {
+        rb_ary_push(result, to_ruby(element).raw());
+      }
+    }
+    return result;
+  })};
+}
+
+template <typename Map> value dump_hash_range(const Map& input) {
+  return value{protect([&input] {
+    VALUE result = rb_hash_new();
+    for (const auto& [key, mapped] : input) {
+      rb_hash_aset(result, to_ruby(key).raw(), to_ruby(mapped).raw());
+    }
+    return result;
+  })};
+}
+
+inline VALUE hash_pairs(VALUE hash) {
+  return protect([hash] { return rb_funcall(hash, rb_intern("to_a"), 0); });
+}
+
+} // namespace rbxx::detail
+// END rbxx/stl/detail.hpp
+
+// BEGIN rbxx/stl/array.hpp
+
+
+#include <array>
+#include <sstream>
+
+namespace rbxx {
+namespace detail {
+template <typename T, std::size_t Size>
+struct is_non_bindable_class<std::array<T, Size>> : std::true_type {};
+} // namespace detail
+
+template <typename T, std::size_t Size> struct type_caster<std::array<T, Size>> {
+  static constexpr std::string_view name = "Array";
+
+  static std::array<T, Size> load(value input) {
+    VALUE array = detail::coerce_array(input);
+    if (RARRAY_LEN(array) != static_cast<long>(Size)) {
+      std::ostringstream message;
+      message << "rbxx: expected Array of length " << Size << ", got " << RARRAY_LEN(array);
+      throw ruby_error(detail::make_exception(rb_eArgError, message.str().c_str()));
+    }
+    return load_elements(array, std::make_index_sequence<Size>{});
+  }
+
+  static value dump(const std::array<T, Size>& input) { return detail::dump_array_range(input); }
+
+  static bool matches(value input) noexcept {
+    return input.is_array() && RARRAY_LEN(input.raw()) == static_cast<long>(Size);
+  }
+
+private:
+  template <std::size_t... Index>
+  static std::array<T, Size> load_elements(VALUE array, std::index_sequence<Index...>) {
+    return {from_ruby<T>(value{RARRAY_AREF(array, static_cast<long>(Index))})...};
+  }
+};
+
+} // namespace rbxx
+// END rbxx/stl/array.hpp
+
+// BEGIN rbxx/stl/chrono.hpp
+
+
+#include <chrono>
+
+namespace rbxx {
+namespace detail {
+template <typename Rep, typename Period>
+struct is_non_bindable_class<std::chrono::duration<Rep, Period>> : std::true_type {};
+} // namespace detail
+
+template <typename Rep, typename Period> struct type_caster<std::chrono::duration<Rep, Period>> {
+  using duration_type = std::chrono::duration<Rep, Period>;
+  static constexpr std::string_view name = "seconds";
+  static duration_type load(value input) {
+    const auto seconds = std::chrono::duration<double>{from_ruby<double>(input)};
+    return std::chrono::duration_cast<duration_type>(seconds);
+  }
+  static value dump(const duration_type& input) {
+    return to_ruby(std::chrono::duration<double>(input).count());
+  }
+  static bool matches(value input) noexcept { return type_caster<double>::matches(input); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/chrono.hpp
+
+// BEGIN rbxx/stl/filesystem.hpp
+
+
+#include <filesystem>
+
+namespace rbxx {
+namespace detail {
+template <> struct is_non_bindable_class<std::filesystem::path> : std::true_type {};
+} // namespace detail
+
+template <> struct type_caster<std::filesystem::path> {
+  static constexpr std::string_view name = "String path";
+  static std::filesystem::path load(value input) {
+    return std::filesystem::path{from_ruby<std::string>(input)};
+  }
+  static value dump(const std::filesystem::path& input) { return to_ruby(input.string()); }
+  static bool matches(value input) noexcept { return type_caster<std::string>::matches(input); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/filesystem.hpp
+
+// BEGIN rbxx/stl/map.hpp
+
+
+#include <map>
+#include <unordered_map>
+
+namespace rbxx {
+namespace detail {
+template <typename Key, typename Mapped, typename Compare, typename Allocator>
+struct is_non_bindable_class<std::map<Key, Mapped, Compare, Allocator>> : std::true_type {};
+template <typename Key, typename Mapped, typename Hash, typename Equal, typename Allocator>
+struct is_non_bindable_class<std::unordered_map<Key, Mapped, Hash, Equal, Allocator>>
+    : std::true_type {};
+
+template <typename Map> Map load_map(value input) {
+  VALUE pairs = hash_pairs(coerce_hash(input));
+  Map result;
+  const long length = RARRAY_LEN(pairs);
+  for (long index = 0; index < length; ++index) {
+    VALUE pair = RARRAY_AREF(pairs, index);
+    using key_type = typename Map::key_type;
+    using mapped_type = typename Map::mapped_type;
+    result.emplace(from_ruby<key_type>(value{RARRAY_AREF(pair, 0)}),
+                   from_ruby<mapped_type>(value{RARRAY_AREF(pair, 1)}));
+  }
+  return result;
+}
+} // namespace detail
+
+template <typename Key, typename Mapped, typename Compare, typename Allocator>
+struct type_caster<std::map<Key, Mapped, Compare, Allocator>> {
+  using map_type = std::map<Key, Mapped, Compare, Allocator>;
+  static constexpr std::string_view name = "Hash";
+  static map_type load(value input) { return detail::load_map<map_type>(input); }
+  static value dump(const map_type& input) { return detail::dump_hash_range(input); }
+  static bool matches(value input) noexcept { return input.is_hash(); }
+};
+
+template <typename Key, typename Mapped, typename Hash, typename Equal, typename Allocator>
+struct type_caster<std::unordered_map<Key, Mapped, Hash, Equal, Allocator>> {
+  using map_type = std::unordered_map<Key, Mapped, Hash, Equal, Allocator>;
+  static constexpr std::string_view name = "Hash";
+  static map_type load(value input) { return detail::load_map<map_type>(input); }
+  static value dump(const map_type& input) { return detail::dump_hash_range(input); }
+  static bool matches(value input) noexcept { return input.is_hash(); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/map.hpp
+
+// BEGIN rbxx/stl/optional.hpp
+
+
+#include <optional>
+
+namespace rbxx {
+namespace detail {
+template <typename T> struct is_non_bindable_class<std::optional<T>> : std::true_type {};
+} // namespace detail
+
+template <typename T> struct type_caster<std::optional<T>> {
+  static constexpr std::string_view name = "Object or nil";
+  static std::optional<T> load(value input) {
+    return input.is_nil() ? std::nullopt : std::optional<T>{from_ruby<T>(input)};
+  }
+  static value dump(const std::optional<T>& input) { return input ? to_ruby(*input) : value{Qnil}; }
+  static bool matches(value input) noexcept {
+    return input.is_nil() || type_caster<T>::matches(input);
+  }
+};
+
+} // namespace rbxx
+// END rbxx/stl/optional.hpp
+
+// BEGIN rbxx/stl/set.hpp
+
+
+#include <set>
+
+namespace rbxx {
+namespace detail {
+template <typename T, typename Compare, typename Allocator>
+struct is_non_bindable_class<std::set<T, Compare, Allocator>> : std::true_type {};
+} // namespace detail
+
+template <typename T, typename Compare, typename Allocator>
+struct type_caster<std::set<T, Compare, Allocator>> {
+  using set_type = std::set<T, Compare, Allocator>;
+  static constexpr std::string_view name = "Array";
+  static set_type load(value input) {
+    VALUE array = detail::coerce_array(input);
+    set_type result;
+    const long length = RARRAY_LEN(array);
+    for (long index = 0; index < length; ++index) {
+      result.insert(from_ruby<T>(value{RARRAY_AREF(array, index)}));
+    }
+    return result;
+  }
+  static value dump(const set_type& input) { return detail::dump_array_range(input); }
+  static bool matches(value input) noexcept { return input.is_array(); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/set.hpp
+
+// BEGIN rbxx/stl/tuple.hpp
+
+
+#include <tuple>
+#include <utility>
+
+namespace rbxx {
+namespace detail {
+template <typename First, typename Second>
+struct is_non_bindable_class<std::pair<First, Second>> : std::true_type {};
+template <typename... Items> struct is_non_bindable_class<std::tuple<Items...>> : std::true_type {};
+
+inline void require_tuple_length(VALUE array, long expected) {
+  if (RARRAY_LEN(array) == expected) {
+    return;
+  }
+  std::string message = "rbxx: expected Array tuple of length ";
+  message += std::to_string(expected);
+  message += ", got ";
+  message += std::to_string(RARRAY_LEN(array));
+  throw ruby_error(make_exception(rb_eArgError, message.c_str()));
+}
+
+template <typename Tuple, std::size_t... Index>
+Tuple load_tuple(VALUE array, std::index_sequence<Index...>) {
+  return Tuple{from_ruby<std::tuple_element_t<Index, Tuple>>(
+      value{RARRAY_AREF(array, static_cast<long>(Index))})...};
+}
+
+template <typename Tuple, std::size_t... Index>
+value dump_tuple(const Tuple& input, std::index_sequence<Index...>) {
+  return value{protect([&input] {
+    VALUE result = rb_ary_new_capa(static_cast<long>(sizeof...(Index)));
+    (rb_ary_push(result, to_ruby(std::get<Index>(input)).raw()), ...);
+    return result;
+  })};
+}
+} // namespace detail
+
+template <typename First, typename Second> struct type_caster<std::pair<First, Second>> {
+  using pair_type = std::pair<First, Second>;
+  static constexpr std::string_view name = "Array(2)";
+  static pair_type load(value input) {
+    VALUE array = detail::coerce_array(input);
+    detail::require_tuple_length(array, 2);
+    return {from_ruby<First>(value{RARRAY_AREF(array, 0)}),
+            from_ruby<Second>(value{RARRAY_AREF(array, 1)})};
+  }
+  static value dump(const pair_type& input) {
+    return detail::dump_tuple(input, std::index_sequence<0, 1>{});
+  }
+  static bool matches(value input) noexcept {
+    return input.is_array() && RARRAY_LEN(input.raw()) == 2;
+  }
+};
+
+template <typename... Items> struct type_caster<std::tuple<Items...>> {
+  using tuple_type = std::tuple<Items...>;
+  static constexpr std::string_view name = "Array tuple";
+  static tuple_type load(value input) {
+    VALUE array = detail::coerce_array(input);
+    detail::require_tuple_length(array, static_cast<long>(sizeof...(Items)));
+    return detail::load_tuple<tuple_type>(array, std::index_sequence_for<Items...>{});
+  }
+  static value dump(const tuple_type& input) {
+    return detail::dump_tuple(input, std::index_sequence_for<Items...>{});
+  }
+  static bool matches(value input) noexcept {
+    return input.is_array() && RARRAY_LEN(input.raw()) == static_cast<long>(sizeof...(Items));
+  }
+};
+
+} // namespace rbxx
+// END rbxx/stl/tuple.hpp
+
+// BEGIN rbxx/stl/variant.hpp
+
+
+#include <variant>
+
+namespace rbxx {
+namespace detail {
+template <typename... Items>
+struct is_non_bindable_class<std::variant<Items...>> : std::true_type {};
+
+template <typename Variant, std::size_t Index = 0> Variant load_variant(value input) {
+  if constexpr (Index == std::variant_size_v<Variant>) {
+    throw_type_error("one of the std::variant alternatives", input);
+  } else {
+    using alternative = std::variant_alternative_t<Index, Variant>;
+    if (type_caster<alternative>::matches(input)) {
+      return Variant{std::in_place_index<Index>, from_ruby<alternative>(input)};
+    }
+    return load_variant<Variant, Index + 1U>(input);
+  }
+}
+} // namespace detail
+
+template <typename... Items> struct type_caster<std::variant<Items...>> {
+  using variant_type = std::variant<Items...>;
+  static constexpr std::string_view name = "variant";
+  static variant_type load(value input) { return detail::load_variant<variant_type>(input); }
+  static value dump(const variant_type& input) {
+    return std::visit([](const auto& selected) { return to_ruby(selected); }, input);
+  }
+  static bool matches(value input) noexcept { return (type_caster<Items>::matches(input) || ...); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/variant.hpp
+
+// BEGIN rbxx/stl/vector.hpp
+
+
+#include <vector>
+
+namespace rbxx {
+namespace detail {
+template <typename T, typename Allocator>
+struct is_non_bindable_class<std::vector<T, Allocator>> : std::true_type {};
+} // namespace detail
+
+template <typename T, typename Allocator> struct type_caster<std::vector<T, Allocator>> {
+  static constexpr std::string_view name = "Array";
+
+  static std::vector<T, Allocator> load(value input) {
+    VALUE array = detail::coerce_array(input);
+    const auto length = RARRAY_LEN(array);
+    std::vector<T, Allocator> result;
+    result.reserve(static_cast<std::size_t>(length));
+    for (long index = 0; index < length; ++index) {
+      result.push_back(from_ruby<T>(value{RARRAY_AREF(array, index)}));
+    }
+    return result;
+  }
+
+  static value dump(const std::vector<T, Allocator>& input) {
+    return detail::dump_array_range(input);
+  }
+
+  static bool matches(value input) noexcept { return input.is_array(); }
+};
+
+} // namespace rbxx
+// END rbxx/stl/vector.hpp
+
+// BEGIN rbxx/stl.hpp
+
+// END rbxx/stl.hpp
+
+// BEGIN rbxx/version.hpp
+
+#define RBXX_VERSION_MAJOR 0
+#define RBXX_VERSION_MINOR 1
+#define RBXX_VERSION_PATCH 0
+#define RBXX_VERSION "0.1.0"
+
+namespace rbxx {
+
+/// @brief The rbxx semantic version string.
+/// @code auto version = rbxx::version; @endcode
+inline constexpr const char* version = RBXX_VERSION;
+
+} // namespace rbxx
+// END rbxx/version.hpp
+
+// BEGIN rbxx/rbxx.hpp
+
+// END rbxx/rbxx.hpp