From 1cf0e8d0a925e36823775122bdb88ed6ff324879 Mon Sep 17 00:00:00 2001
From: Jamieson Pryor <jwhpryor@google.com>
Date: Fri, 23 Jun 2023 13:12:18 -0700
Subject: [PATCH] Rev JNI Bind release header to v 0.9.6.

PiperOrigin-RevId: 542939822
---
 README.md                   |    6 +-
 jni_bind_release.h          | 8922 ++++++++++++++++++-----------------
 jni_bind_release_leader.inc |    2 +-
 3 files changed, 4549 insertions(+), 4381 deletions(-)

diff --git a/README.md b/README.md
index d9d917de..4a280e59 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@
 It requires clang enabled at C++17 or later, is compatible with Android, and is unit / E2E tested on `x86`/`ARM` toolchains.
 
 **Many** features and optimisations are included:
+
 - **Object Management**
 - **Compile time method name and argument checking**
 - **Static caching of IDs** *multi-threading support and compile time signature generation.*
@@ -82,8 +83,8 @@ If you're already using Bazel add the following to your WORKSPACE:
 ```starlark
 http_archive(
   name = "jni-bind",
-  urls = ["https://github.com/google/jni-bind/archive/refs/tags/Release-0.9.5-alpha.zip"],
-  strip_prefix = "jni-bind-Release-0.9.5-alpha",
+  urls = ["https://github.com/google/jni-bind/archive/refs/tags/Release-0.9.6-alpha.zip"],
+  strip_prefix = "jni-bind-Release-0.9.6-alpha",
 )
 ```
 
@@ -474,6 +475,7 @@ Sample [local_array.h](implementation/local_array_test.cc), [array_test_jni.cc](
 ## Upcoming Features
 
 Feature requests are welcome! Some upcoming features are:
+
 - Statics
 - Tighter array type validation (arrays are overly permissive for arguments)
 - Better error messages
diff --git a/jni_bind_release.h b/jni_bind_release.h
index b895e4af..68bd68ae 100644
--- a/jni_bind_release.h
+++ b/jni_bind_release.h
@@ -1400,6 +1400,40 @@ class ConstructorRef : public ConstructorBase {
 
 }  // namespace jni
 
+#include <array>
+#include <string_view>
+
+namespace jni::metaprogramming {
+
+struct StringConcatenate {
+  template <std::string_view const&... Vs>
+  struct Helper {
+    static constexpr auto BuildConcatenation() noexcept {
+      constexpr std::size_t len = (Vs.size() + ... + 0);
+      std::array<char, len + 1> arr{};
+      auto append_single_string =
+          [i = 0, &arr](auto const& string_to_concatenate) mutable {
+            for (auto c : string_to_concatenate) arr[i++] = c;
+          };
+      (append_single_string(Vs), ...);
+      arr[len] = 0;
+
+      return arr;
+    }
+
+    static constexpr auto arr = BuildConcatenation();
+    static constexpr std::string_view value{arr.data(), arr.size() - 1};
+  };
+
+  template <std::string_view const&... Vs>
+  static constexpr std::string_view value = Helper<Vs...>::value;
+};
+
+template <std::string_view const&... Vs>
+static constexpr auto StringConcatenate_v = StringConcatenate::value<Vs...>;
+
+}  // namespace jni::metaprogramming
+
 #include <limits>
 #include <string_view>
 #include <tuple>
@@ -1590,6 +1624,101 @@ using StorageHelper_t = typename StorageHelper<T, kRank>::type;
 
 }  // namespace jni
 
+namespace jni::metaprogramming {
+
+template <std::size_t repeat_cnt>
+struct RepeatString {
+  template <const std::string_view& val_to_repeat>
+  static constexpr std::string_view val = metaprogramming::StringConcatenate_v<
+      val_to_repeat, RepeatString<repeat_cnt - 1>::template val<val_to_repeat>>;
+};
+
+template <>
+struct RepeatString<0> {
+  template <const std::string_view& val_to_repeat>
+  static constexpr std::string_view val{""};
+};
+
+template <std::size_t repeat_cnt, const std::string_view& val_to_repeat>
+static constexpr auto RepeatString_v{
+    RepeatString<repeat_cnt>::template val<val_to_repeat>};
+
+}  // namespace jni::metaprogramming
+
+#include <string_view>
+
+namespace jni::metaprogramming {
+
+struct Constants {
+  static constexpr std::string_view new_line = "\n";
+
+  static constexpr std::string_view left_bracket = "[";
+  static constexpr std::string_view right_bracket = "]";
+
+  static constexpr std::string_view left_parenthesis = "(";
+  static constexpr std::string_view right_parenthesis = ")";
+
+  static constexpr std::string_view hash = "#";
+  static constexpr std::string_view comma = ",";
+  static constexpr std::string_view semi_colon = ";";
+
+  static constexpr std::string_view a = "a";
+  static constexpr std::string_view b = "b";
+  static constexpr std::string_view c = "c";
+  static constexpr std::string_view d = "d";
+  static constexpr std::string_view e = "e";
+  static constexpr std::string_view f = "f";
+  static constexpr std::string_view g = "g";
+  static constexpr std::string_view h = "h";
+  static constexpr std::string_view i = "i";
+  static constexpr std::string_view j = "j";
+  static constexpr std::string_view k = "k";
+  static constexpr std::string_view l = "l";
+  static constexpr std::string_view m = "m";
+  static constexpr std::string_view n = "n";
+  static constexpr std::string_view o = "o";
+  static constexpr std::string_view p = "p";
+  static constexpr std::string_view q = "q";
+  static constexpr std::string_view r = "r";
+  static constexpr std::string_view s = "s";
+  static constexpr std::string_view t = "t";
+  static constexpr std::string_view u = "u";
+  static constexpr std::string_view v = "v";
+  static constexpr std::string_view w = "w";
+  static constexpr std::string_view x = "x";
+  static constexpr std::string_view y = "y";
+  static constexpr std::string_view z = "z";
+
+  static constexpr std::string_view A = "A";
+  static constexpr std::string_view B = "B";
+  static constexpr std::string_view C = "C";
+  static constexpr std::string_view D = "D";
+  static constexpr std::string_view E = "E";
+  static constexpr std::string_view F = "F";
+  static constexpr std::string_view G = "G";
+  static constexpr std::string_view H = "H";
+  static constexpr std::string_view I = "I";
+  static constexpr std::string_view J = "J";
+  static constexpr std::string_view K = "K";
+  static constexpr std::string_view L = "L";
+  static constexpr std::string_view M = "M";
+  static constexpr std::string_view N = "N";
+  static constexpr std::string_view O = "O";
+  static constexpr std::string_view P = "P";
+  static constexpr std::string_view Q = "Q";
+  static constexpr std::string_view R = "R";
+  static constexpr std::string_view S = "S";
+  static constexpr std::string_view T = "T";
+  static constexpr std::string_view U = "U";
+  static constexpr std::string_view V = "V";
+  static constexpr std::string_view W = "W";
+  static constexpr std::string_view X = "X";
+  static constexpr std::string_view Y = "Y";
+  static constexpr std::string_view Z = "Z";
+};
+
+}  // namespace jni::metaprogramming
+
 #include <cstddef>
 #include <initializer_list>
 #include <limits>
@@ -1631,73 +1760,202 @@ constexpr std::size_t ModifiedMax(
 
 }  // namespace jni::metaprogramming
 
-
-#include <type_traits>
+#include <string_view>
 
 namespace jni {
 
-template <typename RawType, std::size_t kRank = 1>
-struct Array;
+// Translates a single JNI term (e.g. jint -> "I") as if it were being used as a
+// parameter to a method.
+//
+// Note, the context a parameter is used on occasion will alter a signature,
+// e.g. void in a return is explicit, whereas when used as a parameter, it is
+// represented as the omission of any value.
+//
+// Additionally, Android will obnoxiously fail to compile the standard looking:
+//    static constexpr char kStr[] = "SomeString";
+//
+// Because it is against style to import a using declaration header wide,
+// but these are also template definitions, they must remain in this header, and
+// so there are goofy looking "using literal" declarations throughout.
+//
+// https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html
+//
+// TODO:  Rename to JavaPrimitiveTypeToString
+template <typename JavaType>
+constexpr std::string_view JavaTypeToString();
 
-template <std::size_t kRank>
-struct Rank {};
+template <>
+constexpr std::string_view JavaTypeToString<void>() {
+  // Note:  This only applies when used as a return, not as a parameter.  This
+  // could be enforced through type system, but maybe feels excessive to do so.
+  // For now, enforcing this is unnecesssary, as this function is only called
+  // for each Param, which, in the case of no params, is 0 times.
+  using namespace std::literals;
+  return "V"sv;
+}
 
-////////////////////////////////////////////////////////////////////////////////
-// Array Non-Object Implementation.
-////////////////////////////////////////////////////////////////////////////////
-template <typename RawType, std::size_t kRank>
-struct ArrayNonObjectTypeImpl {
-  RawType raw_;
+template <>
+constexpr std::string_view JavaTypeToString<jboolean>() {
+  using namespace std::literals;
+  return "Z"sv;
+}
 
-  constexpr ArrayNonObjectTypeImpl(RawType raw) : raw_(raw) {}
+template <>
+constexpr std::string_view JavaTypeToString<jbyte>() {
+  using namespace std::literals;
+  return "B"sv;
+}
 
-  constexpr ArrayNonObjectTypeImpl(RawType raw, Rank<kRank>) : raw_(raw) {}
+template <>
+constexpr std::string_view JavaTypeToString<jchar>() {
+  using namespace std::literals;
+  return "C"sv;
+}
 
-  template <std::size_t kRank_, typename RawType_>
-  constexpr ArrayNonObjectTypeImpl(Array<RawType, kRank>&& invalid_arg)
-      : raw_(nullptr) {
-    static_assert(std::is_same_v<RawType, void>,
-                  "JNI Error: Invalid array declaration, use Array { type{}, "
-                  "Rank<kRank>{} }.");
-  }
+template <>
+constexpr std::string_view JavaTypeToString<jshort>() {
+  using namespace std::literals;
+  return "S"sv;
+}
 
-  template <typename RawTypeRhs, std::size_t kRankRhs>
-  constexpr bool operator==(const Array<RawTypeRhs, kRankRhs>& rhs) const {
-    if constexpr (std::is_same_v<RawType, RawTypeRhs>) {
-      return (raw_ == rhs.raw_);
-    }
-    return false;
-  }
+template <>
+constexpr std::string_view JavaTypeToString<jint>() {
+  using namespace std::literals;
+  return "I"sv;
+}
 
-  template <typename RawTypeRhs, std::size_t kRankRhs>
-  constexpr bool operator!=(const Array<RawTypeRhs, kRankRhs>& rhs) const {
-    return !(*this == rhs);
-  }
-};
+template <>
+constexpr std::string_view JavaTypeToString<jlong>() {
+  using namespace std::literals;
+  return "J"sv;
+}
 
-// Primitive array implementaiton.
-template <typename T, std::size_t kRank, bool HoldsObject>
-struct ArrayImpl : public ArrayNonObjectTypeImpl<T, kRank>,
-                   ArrayTag<RegularToArrayTypeMap_t<T>> {
- public:
-  using ArrayNonObjectTypeImpl<T, kRank>::ArrayNonObjectTypeImpl;
-};
+template <>
+constexpr std::string_view JavaTypeToString<jfloat>() {
+  using namespace std::literals;
+  return "F"sv;
+}
 
-////////////////////////////////////////////////////////////////////////////////
-// Array Object Implementation.
-////////////////////////////////////////////////////////////////////////////////
-template <typename RawType, std::size_t kRank_>
-struct ArrayImpl<RawType, kRank_, true> : public ArrayTag<jobjectArray> {
-  RawType raw_;
+template <>
+constexpr std::string_view JavaTypeToString<jdouble>() {
+  using namespace std::literals;
+  return "D"sv;
+}
 
-  constexpr ArrayImpl(RawType raw) : raw_(raw) {}
+template <>
+constexpr std::string_view JavaTypeToString<jstring>() {
+  using namespace std::literals;
+  return "Ljava/lang/String;"sv;
+}
 
-  template <std::size_t kRank>
-  constexpr ArrayImpl(RawType raw, Rank<kRank>) : raw_(raw) {}
+}  // namespace jni
 
-  template <typename RawTypeRhs, std::size_t kRank>
-  constexpr bool operator==(const Array<RawTypeRhs, kRank>& rhs) const {
-    if constexpr (std::is_same_v<RawType, RawTypeRhs>) {
+#include <string_view>
+#include <type_traits>
+
+namespace jni {
+
+// Metafunction that returns either "" if a member called |name_| isn't
+// present, or a constexpr std::string_view of the name if it is.
+template <const auto&, typename Enable = void>
+struct NameOrNothing {
+  static constexpr std::string_view val{""};
+};
+
+template <const auto& val_>
+struct NameOrNothing<val_, std::void_t<decltype(val_.name_)>> {
+  static constexpr std::string_view val{val_.name_};
+};
+
+template <const auto& val>
+static constexpr auto NameOrNothing_v = NameOrNothing<val>::val;
+
+static constexpr std::string_view kInit{"<init>"};
+
+}  // namespace jni
+
+namespace jni {
+
+enum class IdType {
+  CLASS,
+  STATIC_OVERLOAD_SET,
+  STATIC_OVERLOAD,
+  STATIC_OVERLOAD_PARAM,
+  OVERLOAD_SET,
+  OVERLOAD,
+  OVERLOAD_PARAM,
+  STATIC_FIELD,
+  FIELD,
+};
+
+}  // namespace jni
+
+#include <type_traits>
+
+namespace jni {
+
+template <typename RawType, std::size_t kRank = 1>
+struct Array;
+
+template <std::size_t kRank>
+struct Rank {};
+
+////////////////////////////////////////////////////////////////////////////////
+// Array Non-Object Implementation.
+////////////////////////////////////////////////////////////////////////////////
+template <typename RawType, std::size_t kRank>
+struct ArrayNonObjectTypeImpl {
+  RawType raw_;
+
+  constexpr ArrayNonObjectTypeImpl(RawType raw) : raw_(raw) {}
+
+  constexpr ArrayNonObjectTypeImpl(RawType raw, Rank<kRank>) : raw_(raw) {}
+
+  template <std::size_t kRank_, typename RawType_>
+  constexpr ArrayNonObjectTypeImpl(Array<RawType, kRank>&& invalid_arg)
+      : raw_(nullptr) {
+    static_assert(std::is_same_v<RawType, void>,
+                  "JNI Error: Invalid array declaration, use Array { type{}, "
+                  "Rank<kRank>{} }.");
+  }
+
+  template <typename RawTypeRhs, std::size_t kRankRhs>
+  constexpr bool operator==(const Array<RawTypeRhs, kRankRhs>& rhs) const {
+    if constexpr (std::is_same_v<RawType, RawTypeRhs>) {
+      return (raw_ == rhs.raw_);
+    }
+    return false;
+  }
+
+  template <typename RawTypeRhs, std::size_t kRankRhs>
+  constexpr bool operator!=(const Array<RawTypeRhs, kRankRhs>& rhs) const {
+    return !(*this == rhs);
+  }
+};
+
+// Primitive array implementaiton.
+template <typename T, std::size_t kRank, bool HoldsObject>
+struct ArrayImpl : public ArrayNonObjectTypeImpl<T, kRank>,
+                   ArrayTag<RegularToArrayTypeMap_t<T>> {
+ public:
+  using ArrayNonObjectTypeImpl<T, kRank>::ArrayNonObjectTypeImpl;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Array Object Implementation.
+////////////////////////////////////////////////////////////////////////////////
+template <typename RawType, std::size_t kRank_>
+struct ArrayImpl<RawType, kRank_, true> : public ArrayTag<jobjectArray> {
+  RawType raw_;
+
+  constexpr ArrayImpl(RawType raw) : raw_(raw) {}
+
+  template <std::size_t kRank>
+  constexpr ArrayImpl(RawType raw, Rank<kRank>) : raw_(raw) {}
+
+  template <typename RawTypeRhs, std::size_t kRank>
+  constexpr bool operator==(const Array<RawTypeRhs, kRank>& rhs) const {
+    if constexpr (std::is_same_v<RawType, RawTypeRhs>) {
       return (raw_ == rhs.raw_);
     }
     return false;
@@ -1784,549 +2042,519 @@ constexpr auto FullArrayStripV(const T& val) {
 }  // namespace jni
 
 #include <tuple>
+#include <utility>
 
-namespace jni {
-
-// The set of classes that a ClassLoader can load.
-template <typename... Classes_>
-class SupportedClassSet {
- public:
-  const std::tuple<Classes_...> supported_classes_;
+namespace jni::metaprogramming {
 
-  constexpr SupportedClassSet(Classes_... supported_classes)
-      : supported_classes_(supported_classes...) {
-    // TODO(b/143908983): Classloaders should enforce unique classes.
-    // static_assert(metaprogramming::AllUniqueValues(supported_classes...),
-    //"All classes supported by the class loader must be unique.");
-  }
-};
+// Metafunction to take a sequence of indices, and produce the corresponding
+// elements in sequences of tuples.
+template <std::size_t... sizes>
+struct TypeIndexMask {
+  template <typename, typename... Ts>
+  struct GetHelper {};
 
-template <typename... Classes>
-SupportedClassSet(Classes...) -> SupportedClassSet<Classes...>;
+  template <std::size_t... Is, typename... Ts>
+  struct GetHelper<std::index_sequence<Is...>, Ts...> {
+    using type = std::tuple<TypeOfNthTupleElement_t<Is, Ts>...>;
+  };
 
-}  // namespace jni
+  template <typename... Ts>
+  using Get = typename GetHelper<std::index_sequence<sizes...>, Ts...>::type;
 
+  template <typename>
+  struct SequenceGenerator {};
 
-#include <tuple>
+  template <typename... Ts>
+  struct SequenceGenerator<std::tuple<Ts...>> {
+    using type = Get<Ts...>;
+  };
 
-namespace jni {
+  template <typename Tup>
+  using type = typename SequenceGenerator<Tup>::type;
+};
 
-static constexpr std::size_t kDefaultClassLoaderIdx = 0;
-static constexpr std::size_t kClassNotInLoaderSetIdx =
-    metaprogramming::kNegativeOne;
+template <typename TupOfTypes, std::size_t... sizes>
+using TypeTupFromIndexMask_t =
+    typename TypeIndexMask<sizes...>::template type<TupOfTypes>;
 
-// Class loader that can supply any class (to be used when none is specified).
-// Setting this as the root loader for user defined classes will disable checks
-// that classes are explicitly listed under a loader's class list.
-class DefaultClassLoader {
- public:
-  const char* name_ = "__JNI_BIND_DEFAULT_CLASS_LOADER__";
-  std::tuple<> supported_classes_{};
+}  // namespace jni::metaprogramming
 
-  // Note, this will return true iff ignore_default_loader is true, but the
-  // corresponding IdxOfAncestor will be kClassNotInLoaderSetIdx.
-  template <const auto&, bool ignore_default_loader = false>
-  constexpr bool SupportedDirectlyOrIndirectly() const {
-    if constexpr (ignore_default_loader) {
-      // Note, it's an implementation detail that kDefaultClassLoader returns
-      // false for |SupportedByThisSet|.  Otherwise, all classes will always
-      // defer to the default loader.  See |ParentLoaderForClass|.
-      return false;
-    } else {
-      return true;
-    }
-  }
+#include <algorithm>
+#include <utility>
 
-  template <const auto& class_v>
-  constexpr std::size_t IdxOfClass() const {
-    return kClassNotInLoaderSetIdx;
-  }
+namespace jni::metaprogramming {
 
-  template <const auto& possibly_supported_class>
-  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
-    return kClassNotInLoaderSetIdx;
-  }
+// Represents a value that can be [0, max], and an overflow bit.
+// When incremented, the type will rollover, and set its overflow bit.
+template <size_t cur_value, size_t max = 1, bool overflow_bit = false>
+struct NBit {
+  static constexpr size_t value_ = cur_value;
+  static constexpr size_t overflow_bit_ = overflow_bit;
 
-  template <typename T>
-  bool constexpr operator==(const T& rhs) const {
-    return false;
-  }
-  bool constexpr operator==(const DefaultClassLoader&) const { return true; }
+  // Only unary values will ever need the clamp.
+  using Increment =
+      NBit<(value_ == max ? 0 : std::clamp(value_ + 1, size_t{0}, max)), max,
+           value_ == max>;
 
-  template <typename T>
-  bool constexpr operator!=(const T& rhs) const {
-    return !(*this == rhs);
-  }
+  using ResetOverflow = NBit<cur_value, max, false>;
 };
 
-// Class loader that cannot supply any classes. This should be the root loader
-// for most user defined classes.
-class NullClassLoader {
- public:
-  const char* name_ = "__JNI_BIND_NULL_CLASS_LOADER__";
+}  // namespace jni::metaprogramming
 
-  template <const auto&, bool ignore_default_loader = false>
-  constexpr bool SupportedDirectlyOrIndirectly() const {
-    return false;
-  }
+#include <string_view>
+#include <type_traits>
+#include <utility>
 
-  template <const auto& class_v>
-  constexpr std::size_t IdxOfClass() const {
-    return kNoIdx;
-  }
+#define STR(x) []() { return x; }
 
-  template <const auto& possibly_supported_class>
-  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
-    return kClassNotInLoaderSetIdx;
-  }
+namespace jni::metaprogramming {
 
-  template <typename T>
-  bool constexpr operator==(const T& rhs) const {
-    return false;
-  }
-  bool constexpr operator==(const NullClassLoader&) const { return true; }
+template <typename Identifier>
+using identifier_type = decltype(std::declval<Identifier>()());
 
-  template <typename T>
-  bool constexpr operator!=(const T& rhs) const {
-    return !(*this == rhs);
-  }
-};
+constexpr std::size_t ConstexprStrlen(const char* str) {
+  return str[0] == 0 ? 0 : ConstexprStrlen(str + 1) + 1;
+}
 
-static constexpr NullClassLoader kNullClassLoader;
-static constexpr DefaultClassLoader kDefaultClassLoader;
+struct StringAsTypeBase {};
 
-// DO NOT USE: This obviates a compiler bug for value based enablement on ctor.
-static constexpr auto kShadowNullClassLoader = kNullClassLoader;
+// Represents a string by embedding a sequence of characters in a type.
+template <char... chars>
+struct StringAsType : StringAsTypeBase {
+  static constexpr char static_chars[] = {chars..., 0};
+  static constexpr std::string_view chars_as_sv = {static_chars,
+                                                   sizeof...(chars)};
+};
 
-// DO NOT USE: This obviates a compiler bug for value based enablement on ctor.
-static constexpr auto kShadowDefaultClassLoader = kDefaultClassLoader;
-
-}  // namespace jni
-
-
-namespace jni {
-
-// clang-format off
-inline constexpr Class kJavaLangClass{"java/lang/Class"};
-
-inline constexpr Class kJavaLangObject{"java/lang/Object"};
-
-inline constexpr Class kJavaLangClassLoader{
-    "java/lang/ClassLoader",
-    Method{"loadClass", Return{kJavaLangClass}, Params<jstring>{}},
-    Method{"toString", Return{jstring{}}, Params<>{}},
-};
-
-static constexpr Class kJavaLangString{
-    "java/lang/String",
+template <typename Identifier, std::size_t... I>
+constexpr auto LambdaToStr(Identifier id, std::index_sequence<I...>) {
+  return StringAsType<id()[I]...>{};
+}
 
-    Constructor{jstring{}},
-    Constructor{Array{jbyte{}}},
+template <
+    typename Identifier,
+    std::enable_if_t<std::is_same_v<identifier_type<Identifier>, const char*>,
+                     int> = 0>
+constexpr auto LambdaToStr(Identifier id) {
+  return LambdaToStr(id, std::make_index_sequence<ConstexprStrlen(id())>{});
+}
 
-    Method{"toString", Return{jstring{}}, Params<>{}},
-};
-// clang-format on
+template <typename NameLambda>
+using LambdaStringToType = decltype(LambdaToStr(std::declval<NameLambda>()));
 
-}  // namespace jni
+}  // namespace jni::metaprogramming
 
-#include <array>
-#include <cstddef>
+#include <type_traits>
 #include <utility>
 
 namespace jni::metaprogramming {
 
-// Wrapper to convert a sequence of values into a type.
-template <const auto val_>
-struct Val {
-  using type = decltype(val_);
-  static constexpr type val = val_;
-};
-
-template <const auto val>
-using Val_t = Val<val>;
-
-// Wrapper to convert a sequence of values into a type.
-template <auto... Vs>
-struct Vals {
-  static constexpr std::array val{Vs...};
-};
+// Metafunction to increment types a certain number of times.
+// Types must export a type alias "Increment" which increments the type once.
+template <std::size_t I>
+struct Increment {
+  template <typename T, std::size_t Idx>
+  struct IncrementCountHelper {
+    using type = typename Increment<Idx - 1>::template type<T>::Increment;
+  };
 
-// Wrapper to convert a sequence of const values into a type.
-template <const auto... Vs>
-struct ValsConst {
-  static constexpr std::array val{Vs...};
-};
+  template <typename T>
+  struct IncrementCountHelper<T, 0> {
+    using type = T;
+  };
 
-// Wrapper to convert a sequence of ref values into a type.
-template <auto&... Vs>
-struct ValsRef {
-  static constexpr std::array val{Vs...};
+  template <typename T>
+  using type = typename IncrementCountHelper<T, I>::type;
 };
 
-// Wrapper to convert a sequence of const ref values into a type.
-template <const auto&... Vs>
-struct ValsConstRef {
-  static constexpr std::array val{Vs...};
-};
+template <typename T, std::size_t I = 1>
+using Increment_t = typename Increment<I>::template type<T>;
 
 }  // namespace jni::metaprogramming
 
-#include <array>
-#include <string_view>
+#include <tuple>
+#include <type_traits>
 
 namespace jni::metaprogramming {
 
-struct StringConcatenate {
-  template <std::string_view const&... Vs>
+// Metafunction that detects a partial specialisation for a Container.
+template <template <typename> class Container>
+struct Detect {
+  template <typename T, typename Enable = void>
   struct Helper {
-    static constexpr auto BuildConcatenation() noexcept {
-      constexpr std::size_t len = (Vs.size() + ... + 0);
-      std::array<char, len + 1> arr{};
-      auto append_single_string =
-          [i = 0, &arr](auto const& string_to_concatenate) mutable {
-            for (auto c : string_to_concatenate) arr[i++] = c;
-          };
-      (append_single_string(Vs), ...);
-      arr[len] = 0;
-
-      return arr;
-    }
-
-    static constexpr auto arr = BuildConcatenation();
-    static constexpr std::string_view value{arr.data(), arr.size() - 1};
+    static constexpr bool val = false;
+    using type = std::tuple<>;
   };
 
-  template <std::string_view const&... Vs>
-  static constexpr std::string_view value = Helper<Vs...>::value;
-};
+  template <typename T>
+  struct Helper<T, std::void_t<typename Container<T>::type>> {
+    static constexpr bool val = true;
+    using type = typename Container<T>::type;
+  };
 
-template <std::string_view const&... Vs>
-static constexpr auto StringConcatenate_v = StringConcatenate::value<Vs...>;
+  template <typename T>
+  using type = typename Helper<T>::type;
 
-}  // namespace jni::metaprogramming
+  template <typename T>
+  static constexpr bool val = Helper<T>::val;
+};
 
-#include <string_view>
-#include <type_traits>
-#include <utility>
+template <template <typename> class Container, typename T>
+using Detect_t = typename Detect<Container>::template type<T>;
 
-#define STR(x) []() { return x; }
+template <template <typename> class Container, typename T>
+static constexpr bool Detect_v = Detect<Container>::template val<T>;
 
-namespace jni::metaprogramming {
+}  // namespace jni::metaprogramming
 
-template <typename Identifier>
-using identifier_type = decltype(std::declval<Identifier>()());
+#include <tuple>
 
-constexpr std::size_t ConstexprStrlen(const char* str) {
-  return str[0] == 0 ? 0 : ConstexprStrlen(str + 1) + 1;
-}
+namespace jni {
 
-struct StringAsTypeBase {};
+// The set of classes that a ClassLoader can load.
+template <typename... Classes_>
+class SupportedClassSet {
+ public:
+  const std::tuple<Classes_...> supported_classes_;
 
-// Represents a string by embedding a sequence of characters in a type.
-template <char... chars>
-struct StringAsType : StringAsTypeBase {
-  static constexpr char static_chars[] = {chars..., 0};
-  static constexpr std::string_view chars_as_sv = {static_chars,
-                                                   sizeof...(chars)};
+  constexpr SupportedClassSet(Classes_... supported_classes)
+      : supported_classes_(supported_classes...) {
+    // TODO(b/143908983): Classloaders should enforce unique classes.
+    // static_assert(metaprogramming::AllUniqueValues(supported_classes...),
+    //"All classes supported by the class loader must be unique.");
+  }
 };
 
-template <typename Identifier, std::size_t... I>
-constexpr auto LambdaToStr(Identifier id, std::index_sequence<I...>) {
-  return StringAsType<id()[I]...>{};
-}
-
-template <
-    typename Identifier,
-    std::enable_if_t<std::is_same_v<identifier_type<Identifier>, const char*>,
-                     int> = 0>
-constexpr auto LambdaToStr(Identifier id) {
-  return LambdaToStr(id, std::make_index_sequence<ConstexprStrlen(id())>{});
-}
-
-template <typename NameLambda>
-using LambdaStringToType = decltype(LambdaToStr(std::declval<NameLambda>()));
+template <typename... Classes>
+SupportedClassSet(Classes...) -> SupportedClassSet<Classes...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace jni
 
-#include <utility>
+#include <string_view>
 
 namespace jni {
 
-enum class LifecycleType {
-  LOCAL,
-  GLOBAL,
-  // WEAK, // not implemented yet.
-};
+// Helper to generate full signature information for a "selected" value, and
+// possibly some container information.  Here, |Selector| is |MethodSelection|,
+// |FieldSelection|, etc.
+//
+// Unfortunately, the type system does not permit passing subobjects, however,
+// types can be used that represent a specific selection upon an object.  This
+// consolidates all signature info.
+//
+// |Selector| must express a type alias for RawVal (e.g. jint, Class{...}, etc.)
+// and a type alias |RawValT| which is std::decay_t<RawVal>;
+template <typename Selector>
+struct SelectorStaticInfo {
+  template <std::size_t I>
+  struct IthRawTypeMember {
+    template <typename T>
+    static constexpr const auto& Val(const T& val) {
+      return IthRawTypeMember<I - 1>::Val(val.raw_);
+    }
+  };
 
-template <typename Span, LifecycleType lifecycle_type>
-struct LifecycleHelper;
+  template <>
+  struct IthRawTypeMember<0> {
+    template <typename T>
+    static constexpr const auto& Val(const T& val) {
+      return val;
+    }
+  };
 
-// Shared implementation for local jobjects (jobject, jstring).
-template <typename Span>
-struct LifecycleLocalBase {
-  static inline void Delete(Span object) {
-    JniEnv::GetEnv()->DeleteLocalRef(object);
+  // Strangely, the compiler refuses to peer through Val and loses the
+  // constexpr-ness (i.e std::decay_t<decltype(Val())>; is not a constant
+  // expression).
+  static constexpr inline auto Val() {
+    if constexpr (Selector::kRank == 0) {
+      return Selector::Val();
+    } else {
+      return Selector::Val().raw_;
+    }
   }
 
-  static inline Span NewReference(Span object) {
-    return static_cast<Span>(JniEnv::GetEnv()->NewLocalRef(object));
-  }
-};
+  using RawValT = typename Selector::RawValT;
 
-// Shared implementation for global jobjects (jobject, jstring).
-template <typename Span>
-struct LifecycleGlobalBase {
-  static inline Span Promote(Span object) {
-    jobject ret = JniEnv::GetEnv()->NewGlobalRef(object);
-    JniEnv::GetEnv()->DeleteLocalRef(object);
+  static constexpr inline bool kIsObject = std::is_base_of_v<Object, RawValT>;
+  static constexpr inline bool kIsVoid = std::is_same_v<Void, RawValT>;
+  static constexpr std::size_t kRank = Selector::kRank;
 
-    return static_cast<Span>(ret);
+  static constexpr std::string_view TypeNameOrNothingIfNotAnObject() {
+    if constexpr (kIsObject) {
+      return Val().name_;
+    } else {
+      return "";
+    }
   }
 
-  static inline void Delete(Span object) {
-    JniEnv::GetEnv()->DeleteGlobalRef(object);
+  static constexpr std::string_view kTypeNameOrNothingIfNotAnObject =
+      TypeNameOrNothingIfNotAnObject();
+
+  static constexpr std::string_view kEmptyStr = "";
+  static constexpr std::string_view kModifierStr =
+      (kRank == 0) ? ""
+                   : metaprogramming::RepeatString_v<
+                         kRank, metaprogramming::Constants::left_bracket>;
+
+  static constexpr std::string_view UndecoratedTypeName() {
+    if constexpr (kIsObject) {
+      return metaprogramming::StringConcatenate_v<
+          metaprogramming::Constants::L, kTypeNameOrNothingIfNotAnObject,
+          metaprogramming::Constants::semi_colon>;
+    } else if constexpr (kIsVoid) {
+      return JavaTypeToString<void>();
+    } else {
+      return JavaTypeToString<RawValT>();
+    }
   }
 
-  static inline Span NewReference(Span object) {
-    return static_cast<Span>(JniEnv::GetEnv()->NewGlobalRef(object));
+  static constexpr std::string_view kUndecoratedTypeName =
+      UndecoratedTypeName();
+
+  static constexpr std::string_view TypeName() {
+    return metaprogramming::StringConcatenate_v<kModifierStr,
+                                                kUndecoratedTypeName>;
   }
+
+  static constexpr std::string_view kTypeName = TypeName();
 };
 
 }  // namespace jni
 
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 namespace jni {
 
-inline constexpr struct NoClassLoader {
-} kNoClassLoaderSpecified;
+template <typename TUndecayed>
+struct ProxyHelper;
 
-// This is just the list of classes we expect to be loadable from a class loader
-// and its parent loader.
-//
-// Classes from different loaders are typically incompatible, but Class loaders
-// delegate classes that they cannot directly load to their parent loaders, so
-// classes attached to two different class loaders will still be compatible if
-// they were loaded by a shared parent loader.
-//
-// To annotate a class in a function or field declaration, use `LoadedBy`.
-template <typename ParentLoader_, typename... SupportedClasses_>
-class ClassLoader : public Object {
- public:
-  const ParentLoader_ parent_loader_;
-  const std::tuple<SupportedClasses_...> supported_classes_;
+// See jni::Proxy.
+template <typename T>
+using Proxy_t = typename ProxyHelper<T>::Proxy_t;
 
-  explicit constexpr ClassLoader(const char* class_loader_name)
-      : Object(class_loader_name) {}
+template <typename T>
+using Index_t = typename ProxyHelper<T>::Index;
 
-  // Default classloader (no name needed).
-  explicit constexpr ClassLoader(
-      ParentLoader_ parent_loader,
-      SupportedClassSet<SupportedClasses_...> supported_class_set)
-      __attribute__((
-          enable_if(parent_loader == kDefaultClassLoader,
-                    "You must provide a name for classloaders (except "
-                    "kNullClassLoader and kDefaultClassLoader)")))
-      : Object("__JNI_BIND_DEFAULT_CLASS_LOADER__"),
-        parent_loader_(parent_loader),
-        supported_classes_(supported_class_set.supported_classes_) {}
+template <typename T>
+using CDecl_t = typename ProxyHelper<T>::CDecl;
 
-  // Null classloader (no name needed).
-  explicit constexpr ClassLoader(
-      ParentLoader_ parent_loader,
-      SupportedClassSet<SupportedClasses_...> supported_class_set)
-      __attribute__((
-          enable_if(parent_loader == kNullClassLoader,
-                    "You must provide a name for classloaders (except "
-                    "kNullClassLoader and kDefaultClassLoader)")))
-      : Object("__JNI_BIND_NULL_CLASS_LOADER__"),
-        parent_loader_(parent_loader),
-        supported_classes_(supported_class_set.supported_classes_) {}
+template <typename T, typename Id>
+using Return_t = typename ProxyHelper<T>::template AsReturn_t<Id>;
 
-  // TODO(b/143908983): Loaders should not be able to supply classes that their
-  //  parents do.
-  explicit constexpr ClassLoader(
-      const char* class_loader_name, ParentLoader_ parent_loader,
-      SupportedClassSet<SupportedClasses_...> supported_class_set)
+template <typename T, typename ParamSelection>
+using Arg_t = typename ProxyHelper<T>::template AsArg_t<ParamSelection>;
 
-      : Object(class_loader_name),
-        parent_loader_(parent_loader),
-        supported_classes_(supported_class_set.supported_classes_) {}
+template <typename T>
+using AsDecl_t = typename ProxyHelper<T>::AsDecl_t;
 
-  bool constexpr operator==(
-      const ClassLoader<ParentLoader_, SupportedClasses_...>& rhs) const {
-    return (*this).parent_loader_ == rhs.parent_loader_ &&
-           (*this).supported_classes_ == rhs.supported_classes_;
+// Instead of directly searching for the type, convertible types are sought.
+// E.g. A string like "Foo" the type will be const char[4] not const char*.
+template <typename Query>
+struct IsConvertibleKey {
+  template <typename T>
+  static constexpr bool value =
+      std::is_same_v<Query, std::decay_t<T>> ||
+      std::is_base_of_v<std::decay_t<T>, std::decay_t<Query>> ||
+      std::is_base_of_v<std::decay_t<Query>, std::decay_t<T>>;
+};
+
+template <typename Query, typename T>
+static constexpr bool IsConvertibleKey_v =
+    IsConvertibleKey<Query>::template value<T>;
+
+}  // namespace jni
+
+#include <tuple>
+
+namespace jni {
+
+static constexpr std::size_t kDefaultClassLoaderIdx = 0;
+static constexpr std::size_t kClassNotInLoaderSetIdx =
+    metaprogramming::kNegativeOne;
+
+// Class loader that can supply any class (to be used when none is specified).
+// Setting this as the root loader for user defined classes will disable checks
+// that classes are explicitly listed under a loader's class list.
+class DefaultClassLoader {
+ public:
+  const char* name_ = "__JNI_BIND_DEFAULT_CLASS_LOADER__";
+  std::tuple<> supported_classes_{};
+
+  // Note, this will return true iff ignore_default_loader is true, but the
+  // corresponding IdxOfAncestor will be kClassNotInLoaderSetIdx.
+  template <const auto&, bool ignore_default_loader = false>
+  constexpr bool SupportedDirectlyOrIndirectly() const {
+    if constexpr (ignore_default_loader) {
+      // Note, it's an implementation detail that kDefaultClassLoader returns
+      // false for |SupportedByThisSet|.  Otherwise, all classes will always
+      // defer to the default loader.  See |ParentLoaderForClass|.
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  template <const auto& class_v>
+  constexpr std::size_t IdxOfClass() const {
+    return kClassNotInLoaderSetIdx;
+  }
+
+  template <const auto& possibly_supported_class>
+  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
+    return kClassNotInLoaderSetIdx;
   }
+
   template <typename T>
   bool constexpr operator==(const T& rhs) const {
     return false;
   }
+  bool constexpr operator==(const DefaultClassLoader&) const { return true; }
+
   template <typename T>
   bool constexpr operator!=(const T& rhs) const {
     return !(*this == rhs);
   }
+};
 
-  template <const auto& class_v, std::size_t... Is>
-  constexpr std::size_t IdxOfClassHelper(
-      std::integer_sequence<std::size_t, Is...>) const {
-    // std::max appears to be missing the initializer list overload in Bazel's
-    // implementation of clang.  This should simply be std::max.
-    return metaprogramming::ModifiedMax(
-        {((std::get<Is>(supported_classes_) == class_v)
-              ? std::size_t{Is}
-              : metaprogramming::kNegativeOne)...,
-         metaprogramming::kNegativeOne});
+// Class loader that cannot supply any classes. This should be the root loader
+// for most user defined classes.
+class NullClassLoader {
+ public:
+  const char* name_ = "__JNI_BIND_NULL_CLASS_LOADER__";
+
+  template <const auto&, bool ignore_default_loader = false>
+  constexpr bool SupportedDirectlyOrIndirectly() const {
+    return false;
   }
 
-  // Returns the index for a given class within this set (any given class ref is
-  // defined by this index).
   template <const auto& class_v>
   constexpr std::size_t IdxOfClass() const {
-    return IdxOfClassHelper<class_v>(
-        std::make_integer_sequence<std::size_t,
-                                   sizeof...(SupportedClasses_)>());
+    return kNoIdx;
   }
 
-  // Tests if a class is supported by this class loader (not ancestors).
   template <const auto& possibly_supported_class>
-  constexpr bool SupportedByThisSet() const {
-    return IdxOfClass<possibly_supported_class>() != kClassNotInLoaderSetIdx;
+  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
+    return kClassNotInLoaderSetIdx;
   }
 
-  // Tests if a class is supported by this class loader (ancestors included).
-  template <const auto& possibly_supported_class,
-            bool ignore_default_loader = false>
-  constexpr bool SupportedDirectlyOrIndirectly() const {
-    return parent_loader_.template SupportedDirectlyOrIndirectly<
-               possibly_supported_class>() ||
-           SupportedByThisSet<possibly_supported_class>();
+  template <typename T>
+  bool constexpr operator==(const T& rhs) const {
+    return false;
   }
+  bool constexpr operator==(const NullClassLoader&) const { return true; }
 
-  // Returns the index for parent-most ancestor that supports a given class.
-  template <const auto& possibly_supported_class>
-  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
-    if (SupportedByThisSet<possibly_supported_class>() &&
-        !parent_loader_.template SupportedDirectlyOrIndirectly<
-            possibly_supported_class, true>()) {
-      return cur_idx;
-    }
-    return parent_loader_.template IdxOfAncestor<possibly_supported_class>(
-        cur_idx + 1);
+  template <typename T>
+  bool constexpr operator!=(const T& rhs) const {
+    return !(*this == rhs);
   }
 };
 
-// Note: Null is chosen, not default, because LoadedBy requires a syntax like
-// LoadedBy{ClassLoader{"kClass"}} (using the CTAD loader type below), but
-// we want to prevent explicit usage of a default loader (as it makes no sense).
-ClassLoader(const char*)
-    -> ClassLoader<std::decay_t<decltype(kNullClassLoader)>>;
+static constexpr NullClassLoader kNullClassLoader;
+static constexpr DefaultClassLoader kDefaultClassLoader;
 
-template <typename ParentLoader_, typename... SupportedClasses_>
-ClassLoader(ParentLoader_ parent_loader,
-            SupportedClassSet<SupportedClasses_...> supported_classes)
-    -> ClassLoader<ParentLoader_, SupportedClasses_...>;
+// DO NOT USE: This obviates a compiler bug for value based enablement on ctor.
+static constexpr auto kShadowNullClassLoader = kNullClassLoader;
 
-template <typename... SupportedClasses_>
-ClassLoader(SupportedClassSet<SupportedClasses_...>)
-    -> ClassLoader<DefaultClassLoader, SupportedClasses_...>;
+// DO NOT USE: This obviates a compiler bug for value based enablement on ctor.
+static constexpr auto kShadowDefaultClassLoader = kDefaultClassLoader;
 
-template <typename T, std::size_t I>
-constexpr auto& GetAncestor(const T& loader) {
-  if constexpr (I == 0) {
-    return loader;
-  } else {
-    return GetAncestor<decltype(loader.parent_loader_), I - 1>(
-        loader.parent_loader_);
-  }
-}
+}  // namespace jni
 
-template <const auto& loader, const auto& possibly_supported_class>
-constexpr const auto& ParentLoaderForClass() {
-  if constexpr (!loader.template SupportedDirectlyOrIndirectly<
-                    possibly_supported_class>()) {
-    return kNullClassLoader;
-  } else if constexpr (loader.template IdxOfAncestor<
-                           possibly_supported_class>() !=
-                       kClassNotInLoaderSetIdx) {
-    return GetAncestor<
-        decltype(loader),
-        loader.template IdxOfAncestor<possibly_supported_class>()>(loader);
-  } else {
-    return kDefaultClassLoader;
-  }
-}
 
-}  // namespace jni
+namespace jni {
+
+// clang-format off
+inline constexpr Class kJavaLangClass{"java/lang/Class"};
+
+inline constexpr Class kJavaLangObject{"java/lang/Object"};
+
+inline constexpr Class kJavaLangClassLoader{
+    "java/lang/ClassLoader",
+    Method{"loadClass", Return{kJavaLangClass}, Params<jstring>{}},
+    Method{"toString", Return{jstring{}}, Params<>{}},
+};
+
+static constexpr Class kJavaLangString{
+    "java/lang/String",
 
+    Constructor{jstring{}},
+    Constructor{Array{jbyte{}}},
+
+    Method{"toString", Return{jstring{}}, Params<>{}},
+};
+// clang-format on
+
+}  // namespace jni
 
+#include <array>
 #include <cstddef>
 #include <utility>
 
 namespace jni::metaprogramming {
 
-// Performs a deep equality comparison of T, but is leniant about containers.
-// Returns true iff types are equal or both types are containers and their
-// non-type template parameters are equal.
-template <typename T>
-struct ValsEqual {
-  template <typename T1, typename T2, typename Enable = void>
-  struct Helper {
-    static constexpr bool val = std::is_same_v<T1, T2>;
-  };
+// Wrapper to convert a sequence of values into a type.
+template <const auto val_>
+struct Val {
+  using type = decltype(val_);
+  static constexpr type val = val_;
+};
 
-  // Value comparison.
-  template <template <const auto...> class Container1, const auto... V1s_,
-            template <const auto...> class Container2, const auto... V2s_>
-  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
-                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
-    static constexpr bool val = true;
-  };
+template <const auto val>
+using Val_t = Val<val>;
 
-  // LHS l-reference, RHS value.
-  template <template <const auto&...> class Container1, const auto&... V1s_,
-            template <const auto...> class Container2, const auto... V2s_>
-  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
-                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
-    static constexpr bool val = true;
-  };
+// Wrapper to convert a sequence of values into a type.
+template <auto... Vs>
+struct Vals {
+  static constexpr std::array val{Vs...};
+};
 
-  // LHS value, RHS l-reference.
-  template <template <const auto...> class Container1, const auto... V1s_,
-            template <const auto&...> class Container2, const auto&... V2s_>
-  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
-                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
-    static constexpr bool val = true;
-  };
+// Wrapper to convert a sequence of const values into a type.
+template <const auto... Vs>
+struct ValsConst {
+  static constexpr std::array val{Vs...};
+};
 
-  // RHS l-reference, RHS l-reference.
-  template <template <const auto&...> class Container1, const auto&... V1s_,
-            template <const auto&...> class Container2, const auto&... V2s_>
-  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
-                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
-    static constexpr bool val = true;
-  };
+// Wrapper to convert a sequence of ref values into a type.
+template <auto&... Vs>
+struct ValsRef {
+  static constexpr std::array val{Vs...};
+};
 
-  template <typename T2>
-  static constexpr bool val = Helper<T, T2>::val;
+// Wrapper to convert a sequence of const ref values into a type.
+template <const auto&... Vs>
+struct ValsConstRef {
+  static constexpr std::array val{Vs...};
 };
 
-template <typename T1, typename T2>
-static constexpr bool ValsEqual_v = ValsEqual<T1>::template val<T2>;
+}  // namespace jni::metaprogramming
 
-template <auto V1, auto V2>
-static constexpr bool ValsEqual_v_v =
-    ValsEqual<Vals<V1>>::template val<Vals<V2>>;
+#include <tuple>
 
-template <auto& V1, auto& V2>
-static constexpr bool ValsEqual_r_v =
-    ValsEqual<ValsRef<V1>>::template val<ValsRef<V2>>;
+namespace jni::metaprogramming {
 
-template <const auto& V1, const auto& V2>
-static constexpr bool ValsEqual_cr_v =
-    ValsEqual<ValsConstRef<V1>>::template val<ValsConstRef<V2>>;
+struct Reverse {
+  template <typename... Ts>
+  struct Helper {
+    using type = std::tuple<>;
+  };
+
+  template <typename... Ts>
+  using Helper_t = typename Helper<std::tuple<Ts...>>::type;
+
+  template <typename T1, typename... Ts>
+  struct Helper<std::tuple<T1, Ts...>> {
+    using type = ConcatenateTup_t<Helper_t<Ts...>, std::tuple<T1>>;
+  };
+
+  template <typename... Ts>
+  using type = Helper_t<Ts...>;
+};
+
+template <typename... Ts>
+using Reverse_t = typename Reverse::template type<Ts...>;
+
+template <typename Tup>
+using Reverse_Tup = TupleUnroller_t<Reverse, Tup>;
 
 }  // namespace jni::metaprogramming
 
@@ -2357,4833 +2585,4795 @@ static constexpr auto Replace_v =
 
 }  // namespace jni::metaprogramming
 
+#include <algorithm>
+#include <tuple>
+#include <utility>
+
 namespace jni::metaprogramming {
 
-template <std::size_t repeat_cnt>
-struct RepeatString {
-  template <const std::string_view& val_to_repeat>
-  static constexpr std::string_view val = metaprogramming::StringConcatenate_v<
-      val_to_repeat, RepeatString<repeat_cnt - 1>::template val<val_to_repeat>>;
-};
+template <typename...>
+struct NBitSequence {};
 
 template <>
-struct RepeatString<0> {
-  template <const std::string_view& val_to_repeat>
-  static constexpr std::string_view val{""};
+struct NBitSequence<> {
+  using Increment = NBitSequence<>;
 };
 
-template <std::size_t repeat_cnt, const std::string_view& val_to_repeat>
-static constexpr auto RepeatString_v{
-    RepeatString<repeat_cnt>::template val<val_to_repeat>};
-
-}  // namespace jni::metaprogramming
+// Represents a sequence of "NBits".  This can be useful for generating
+// selections of pools of objects of various sizes.
+//
+// For a sequence with N values, a tuple of size N that contains tuples whose
+// sizes match those of max_values can be selected from using TypeMask.
+//
+// In other words, a sequence of N sets of sizes K0, K1, K2...KN can represent a
+// single selection with an NBitSequence where sizeof...(values) == N and
+// sizeof...(max_values) == N where Ki == max_values[i].
+template <size_t... values, size_t... max_values, bool... overflows>
+struct NBitSequence<NBit<values, max_values, overflows>...> {
+  static constexpr size_t sequence_size_ = sizeof...(values);
 
-#include <string_view>
+  using Sequence = std::tuple<NBit<values, max_values, overflows>...>;
+  using TypeMask = TypeIndexMask<values...>;
 
-namespace jni::metaprogramming {
+  template <size_t I>
+  using GetBit = TypeOfNthTupleElement_t<I, Sequence>;
 
-struct Constants {
-  static constexpr std::string_view new_line = "\n";
+  // Helper method to compare values of all NBits.
+  template <size_t... Bits>
+  static constexpr bool Same(std::index_sequence<Bits...> = {}) {
+    static_assert(sizeof...(Bits) == sizeof...(values));
+    return std::is_same_v<std::index_sequence<values...>,
+                          std::index_sequence<Bits...>>;
+  }
 
-  static constexpr std::string_view left_bracket = "[";
-  static constexpr std::string_view right_bracket = "]";
+  static constexpr size_t max_representable_size_ = ((max_values + 1) * ...);
 
-  static constexpr std::string_view left_parenthesis = "(";
-  static constexpr std::string_view right_parenthesis = ")";
+  template <size_t... Bits>
+  static constexpr bool same_ = Same(std::index_sequence<Bits...>{});
 
-  static constexpr std::string_view hash = "#";
-  static constexpr std::string_view comma = ",";
-  static constexpr std::string_view semi_colon = ";";
+  // If the next bit is overflowing (i.e. it just rolled over), this current
+  // value increments. Bits only overflow for a single cycle, otherwise higher
+  // order bits flip when no rollover is happening.
+  template <size_t I>
+  struct IncrementedBit {
+    using type = std::conditional_t<IncrementedBit<I + 1>::type::overflow_bit_,
+                                    typename GetBit<I>::Increment,
+                                    typename GetBit<I>::ResetOverflow>;
+  };
 
-  static constexpr std::string_view a = "a";
-  static constexpr std::string_view b = "b";
-  static constexpr std::string_view c = "c";
-  static constexpr std::string_view d = "d";
-  static constexpr std::string_view e = "e";
-  static constexpr std::string_view f = "f";
-  static constexpr std::string_view g = "g";
-  static constexpr std::string_view h = "h";
-  static constexpr std::string_view i = "i";
-  static constexpr std::string_view j = "j";
-  static constexpr std::string_view k = "k";
-  static constexpr std::string_view l = "l";
-  static constexpr std::string_view m = "m";
-  static constexpr std::string_view n = "n";
-  static constexpr std::string_view o = "o";
-  static constexpr std::string_view p = "p";
-  static constexpr std::string_view q = "q";
-  static constexpr std::string_view r = "r";
-  static constexpr std::string_view s = "s";
-  static constexpr std::string_view t = "t";
-  static constexpr std::string_view u = "u";
-  static constexpr std::string_view v = "v";
-  static constexpr std::string_view w = "w";
-  static constexpr std::string_view x = "x";
-  static constexpr std::string_view y = "y";
-  static constexpr std::string_view z = "z";
+  template <>
+  struct IncrementedBit<sequence_size_ - 1> {
+    using type = typename GetBit<sequence_size_ - 1>::Increment;
+  };
 
-  static constexpr std::string_view A = "A";
-  static constexpr std::string_view B = "B";
-  static constexpr std::string_view C = "C";
-  static constexpr std::string_view D = "D";
-  static constexpr std::string_view E = "E";
-  static constexpr std::string_view F = "F";
-  static constexpr std::string_view G = "G";
-  static constexpr std::string_view H = "H";
-  static constexpr std::string_view I = "I";
-  static constexpr std::string_view J = "J";
-  static constexpr std::string_view K = "K";
-  static constexpr std::string_view L = "L";
-  static constexpr std::string_view M = "M";
-  static constexpr std::string_view N = "N";
-  static constexpr std::string_view O = "O";
-  static constexpr std::string_view P = "P";
-  static constexpr std::string_view Q = "Q";
-  static constexpr std::string_view R = "R";
-  static constexpr std::string_view S = "S";
-  static constexpr std::string_view T = "T";
-  static constexpr std::string_view U = "U";
-  static constexpr std::string_view V = "V";
-  static constexpr std::string_view W = "W";
-  static constexpr std::string_view X = "X";
-  static constexpr std::string_view Y = "Y";
-  static constexpr std::string_view Z = "Z";
-};
+  template <typename index_sequence>
+  struct IncrementSequenceHelper {};
 
-}  // namespace jni::metaprogramming
+  template <size_t... Is>
+  struct IncrementSequenceHelper<std::index_sequence<Is...>> {
+    using type = NBitSequence<typename IncrementedBit<Is>::type...>;
+  };
+
+  using Increment = typename IncrementSequenceHelper<
+      std::make_index_sequence<sequence_size_>>::type;
+};
+
+}  // namespace jni::metaprogramming
+
+#include <utility>
 
 namespace jni {
 
-// jobject.
-template <>
-struct LifecycleHelper<jobject, LifecycleType::LOCAL>
-    : public LifecycleLocalBase<jobject> {
-  template <typename... CtorArgs>
-  static inline jobject Construct(jclass clazz, jmethodID ctor_method,
-                                  CtorArgs&&... ctor_args) {
-    return JniEnv::GetEnv()->NewObject(clazz, ctor_method, ctor_args...);
-  }
+enum class LifecycleType {
+  LOCAL,
+  GLOBAL,
+  // WEAK, // not implemented yet.
 };
 
-template <>
-struct LifecycleHelper<jobject, LifecycleType::GLOBAL>
-    : public LifecycleGlobalBase<jobject> {
-  template <typename... CtorArgs>
-  static inline jobject Construct(jclass clazz, jmethodID ctor_method,
-                                  CtorArgs&&... ctor_args) {
-    using Local = LifecycleHelper<jobject, LifecycleType::LOCAL>;
+template <typename Span, LifecycleType lifecycle_type>
+struct LifecycleHelper;
 
-    jobject local_object = Local::Construct(
-        clazz, ctor_method, std::forward<CtorArgs&&>(ctor_args)...);
-    jobject global_object = Promote(local_object);
-    Local::Delete(local_object);
+// Shared implementation for local jobjects (jobject, jstring).
+template <typename Span>
+struct LifecycleLocalBase {
+  static inline void Delete(Span object) {
+    JniEnv::GetEnv()->DeleteLocalRef(object);
+  }
 
-    return global_object;
+  static inline Span NewReference(Span object) {
+    return static_cast<Span>(JniEnv::GetEnv()->NewLocalRef(object));
   }
 };
 
-// jclass.
-template <>
-struct LifecycleHelper<jclass, LifecycleType::LOCAL>
-    : public LifecycleLocalBase<jclass> {};
+template <typename Span>
+struct LifecycleHelper<Span, LifecycleType::LOCAL>
+    : public LifecycleLocalBase<Span> {
+  using Base = LifecycleLocalBase<Span>;
+  using Base::Base;
+};
 
-template <>
-struct LifecycleHelper<jclass, LifecycleType::GLOBAL>
-    : public LifecycleGlobalBase<jclass> {};
+// Shared implementation for global jobjects (jobject, jstring).
+template <typename Span>
+struct LifecycleGlobalBase {
+  static inline Span Promote(Span object) {
+    jobject ret = JniEnv::GetEnv()->NewGlobalRef(object);
+    JniEnv::GetEnv()->DeleteLocalRef(object);
 
-}  // namespace jni
+    return static_cast<Span>(ret);
+  }
 
-#include <string_view>
+  static inline void Delete(Span object) {
+    JniEnv::GetEnv()->DeleteGlobalRef(object);
+  }
 
-namespace jni {
+  static inline Span NewReference(Span object) {
+    return static_cast<Span>(JniEnv::GetEnv()->NewGlobalRef(object));
+  }
+};
 
-// Translates a single JNI term (e.g. jint -> "I") as if it were being used as a
-// parameter to a method.
-//
-// Note, the context a parameter is used on occasion will alter a signature,
-// e.g. void in a return is explicit, whereas when used as a parameter, it is
-// represented as the omission of any value.
-//
-// Additionally, Android will obnoxiously fail to compile the standard looking:
-//    static constexpr char kStr[] = "SomeString";
-//
-// Because it is against style to import a using declaration header wide,
-// but these are also template definitions, they must remain in this header, and
-// so there are goofy looking "using literal" declarations throughout.
-//
-// https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html
-//
-// TODO:  Rename to JavaPrimitiveTypeToString
-template <typename JavaType>
-constexpr std::string_view JavaTypeToString();
+template <typename Span>
+struct LifecycleHelper<Span, LifecycleType::GLOBAL>
+    : public LifecycleLocalBase<Span> {
+  using Base = LifecycleGlobalBase<Span>;
+  using Base::Base;
+};
 
-template <>
-constexpr std::string_view JavaTypeToString<void>() {
-  // Note:  This only applies when used as a return, not as a parameter.  This
-  // could be enforced through type system, but maybe feels excessive to do so.
-  // For now, enforcing this is unnecesssary, as this function is only called
-  // for each Param, which, in the case of no params, is 0 times.
-  using namespace std::literals;
-  return "V"sv;
-}
+}  // namespace jni
 
-template <>
-constexpr std::string_view JavaTypeToString<jboolean>() {
-  using namespace std::literals;
-  return "Z"sv;
-}
+#include <type_traits>
 
-template <>
-constexpr std::string_view JavaTypeToString<jbyte>() {
-  using namespace std::literals;
-  return "B"sv;
-}
+namespace jni {
 
-template <>
-constexpr std::string_view JavaTypeToString<jchar>() {
-  using namespace std::literals;
-  return "C"sv;
-}
+template <typename JniT_, IdType kIdType_, std::size_t idx,
+          std::size_t secondary_idx, std::size_t tertiary_idx>
+struct Id;
 
-template <>
-constexpr std::string_view JavaTypeToString<jshort>() {
-  using namespace std::literals;
-  return "S"sv;
-}
+// Takes an Id and produces its signature.
+template <typename>
+struct Signature {};
 
-template <>
-constexpr std::string_view JavaTypeToString<jint>() {
-  using namespace std::literals;
-  return "I"sv;
-}
+template <typename JniT_, IdType kIdType_, std::size_t idx,
+          std::size_t secondary_idx, std::size_t tertiary_idx>
+struct Signature<Id<JniT_, kIdType_, idx, secondary_idx, tertiary_idx>> {
+  using IdT = Id<JniT_, kIdType_, idx, secondary_idx, tertiary_idx>;
 
-template <>
-constexpr std::string_view JavaTypeToString<jlong>() {
-  using namespace std::literals;
-  return "J"sv;
-}
+  static constexpr IdType kChildIdType = kIdType_ == IdType::OVERLOAD
+                                             ? IdType::OVERLOAD_PARAM
+                                             : IdType::STATIC_OVERLOAD_PARAM;
 
-template <>
-constexpr std::string_view JavaTypeToString<jfloat>() {
-  using namespace std::literals;
-  return "F"sv;
-}
+  template <typename IdxPack>
+  struct Helper;
 
-template <>
-constexpr std::string_view JavaTypeToString<jdouble>() {
-  using namespace std::literals;
-  return "D"sv;
-}
+  template <std::size_t... Is>
+  struct Helper<std::index_sequence<Is...>> {
+    template <std::size_t I>
+    struct Val {
+      static constexpr std::string_view val =
+          Signature<Id<JniT_, kChildIdType, idx, secondary_idx, I>>::val;
+    };
 
-template <>
-constexpr std::string_view JavaTypeToString<jstring>() {
-  using namespace std::literals;
-  return "Ljava/lang/String;"sv;
-}
+    static constexpr std::string_view val =
+        metaprogramming::StringConcatenate_v<Val<Is>::val...>;
+  };
 
-}  // namespace jni
+  struct ReturnHelper {
+    static constexpr std::string_view val =
+        Signature<Id<JniT_, kChildIdType, idx, secondary_idx, kNoIdx>>::val;
+  };
 
-#include <type_traits>
+  // For methods and ctors generates the signature, e.g. "(II)LClass1;".
+  // For parameters, emits just a type name.
+  static constexpr std::string_view Val() {
+    if constexpr (kIdType_ == IdType::FIELD ||
+                  kIdType_ == IdType::STATIC_FIELD) {
+      return SelectorStaticInfo<IdT>::TypeName();
+    } else if constexpr (kIdType_ == IdType::OVERLOAD_SET) {
+      return "NOT_IMPLEMENTED";
+    } else if constexpr (kIdType_ == IdType::OVERLOAD ||
+                         kIdType_ == IdType::STATIC_OVERLOAD) {
+      using Idxs = std::make_index_sequence<IdT::NumParams()>;
+      if constexpr (IdT::kIsConstructor) {
+        return metaprogramming::StringConcatenate_v<
+            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
+            metaprogramming::Constants::right_parenthesis,
+            metaprogramming::Constants::V>;
+      } else {
+        return metaprogramming::StringConcatenate_v<
+            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
+            metaprogramming::Constants::right_parenthesis, ReturnHelper::val>;
+      }
+    } else if constexpr (kIdType_ == IdType::OVERLOAD_PARAM ||
+                         kIdType_ == IdType::STATIC_OVERLOAD_PARAM) {
+      return SelectorStaticInfo<IdT>::TypeName();
+    }
 
-namespace jni {
+    return "NOT_IMPLEMENTED";
+  }
 
-// Convenience struct for returning results from pinning array.
-template <typename SpanType>
-struct GetArrayElementsResult {
-  SpanType* ptr_;
-  jboolean is_copy;
+  static constexpr std::string_view val{Val()};
 };
 
-struct JniArrayHelperBase {
-  static inline std::size_t GetLength(jarray array) {
-    return jni::JniEnv::GetEnv()->GetArrayLength(array);
-  }
-};
+template <typename T>
+static constexpr auto Signature_v = Signature<T>::val;
 
-// Rank 2+ arrays all behave like object arrays.
-template <typename SpannedType, std::size_t kRank>
-struct JniArrayHelper : public JniArrayHelperBase {
-  static inline jobjectArray NewArray(std::size_t size, jclass class_id,
-                                      jobject initial_element) {
-    return jni::JniEnv::GetEnv()->NewObjectArray(size, class_id,
-                                                 initial_element);
-  }
+}  // namespace jni
 
-  // The API of fetching objects only permits accessing one object at a time.
-  static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
-    return jni::JniEnv::GetEnv()->GetObjectArrayElement(array, idx);
-  };
+namespace jni {
 
-  // The API of fetching objects only permits accessing one object at a time.
-  static inline void SetArrayElement(jobjectArray array, std::size_t idx,
-                                     SpannedType obj) {
-    jni::JniEnv::GetEnv()->SetObjectArrayElement(array, idx, obj);
-  };
-};
+// Provide this base tag to UserDefined to enable custom types.
+struct JniUserDefinedCorpusTag {};
 
-template <>
-struct JniArrayHelper<jboolean, 1> : public JniArrayHelperBase {
-  using AsArrayType = jbooleanArray;
+// Provide a partial specialization to this class to provide custom types.
+template <typename T>
+struct UserDefined;
 
-  static inline jbooleanArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewBooleanArray(size);
-  }
+}  // namespace jni
 
-  static inline GetArrayElementsResult<jboolean> GetArrayElements(
-      jarray array) {
-    GetArrayElementsResult<jboolean> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetBooleanArrayElements(
-        static_cast<jbooleanArray>(array), &return_value.is_copy);
-    return return_value;
-  }
+#include <tuple>
+#include <type_traits>
+#include <utility>
 
-  static inline void ReleaseArrayElements(jarray array, jboolean* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseBooleanArrayElements(
-        static_cast<jbooleanArray>(array), native_ptr, copy_back_mode);
-  }
-};
+namespace jni {
 
-template <>
-struct JniArrayHelper<jbyte, 1> : public JniArrayHelperBase {
-  using AsArrayType = jbyteArray;
+inline constexpr struct NoClassLoader {
+} kNoClassLoaderSpecified;
 
-  static inline jbyteArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewByteArray(size);
-  }
+// This is just the list of classes we expect to be loadable from a class loader
+// and its parent loader.
+//
+// Classes from different loaders are typically incompatible, but Class loaders
+// delegate classes that they cannot directly load to their parent loaders, so
+// classes attached to two different class loaders will still be compatible if
+// they were loaded by a shared parent loader.
+//
+// To annotate a class in a function or field declaration, use `LoadedBy`.
+template <typename ParentLoader_, typename... SupportedClasses_>
+class ClassLoader : public Object {
+ public:
+  const ParentLoader_ parent_loader_;
+  const std::tuple<SupportedClasses_...> supported_classes_;
 
-  static inline GetArrayElementsResult<jbyte> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jbyte> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetByteArrayElements(
-        static_cast<jbyteArray>(array), &return_value.is_copy);
-    return return_value;
-  }
+  explicit constexpr ClassLoader(const char* class_loader_name)
+      : Object(class_loader_name) {}
 
-  static inline void ReleaseArrayElements(jarray array, jbyte* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseByteArrayElements(
-        static_cast<jbyteArray>(array), native_ptr, copy_back_mode);
-  }
-};
+  // Default classloader (no name needed).
+  explicit constexpr ClassLoader(
+      ParentLoader_ parent_loader,
+      SupportedClassSet<SupportedClasses_...> supported_class_set)
+      __attribute__((
+          enable_if(parent_loader == kDefaultClassLoader,
+                    "You must provide a name for classloaders (except "
+                    "kNullClassLoader and kDefaultClassLoader)")))
+      : Object("__JNI_BIND_DEFAULT_CLASS_LOADER__"),
+        parent_loader_(parent_loader),
+        supported_classes_(supported_class_set.supported_classes_) {}
 
-template <>
-struct JniArrayHelper<jchar, 1> : public JniArrayHelperBase {
-  using AsArrayType = jcharArray;
+  // Null classloader (no name needed).
+  explicit constexpr ClassLoader(
+      ParentLoader_ parent_loader,
+      SupportedClassSet<SupportedClasses_...> supported_class_set)
+      __attribute__((
+          enable_if(parent_loader == kNullClassLoader,
+                    "You must provide a name for classloaders (except "
+                    "kNullClassLoader and kDefaultClassLoader)")))
+      : Object("__JNI_BIND_NULL_CLASS_LOADER__"),
+        parent_loader_(parent_loader),
+        supported_classes_(supported_class_set.supported_classes_) {}
 
-  static inline jcharArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewCharArray(size);
-  }
+  // TODO(b/143908983): Loaders should not be able to supply classes that their
+  //  parents do.
+  explicit constexpr ClassLoader(
+      const char* class_loader_name, ParentLoader_ parent_loader,
+      SupportedClassSet<SupportedClasses_...> supported_class_set)
 
-  static inline GetArrayElementsResult<jchar> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jchar> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetCharArrayElements(
-        static_cast<jcharArray>(array), &return_value.is_copy);
-    return return_value;
-  }
+      : Object(class_loader_name),
+        parent_loader_(parent_loader),
+        supported_classes_(supported_class_set.supported_classes_) {}
 
-  static inline void ReleaseArrayElements(jarray array, jchar* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseCharArrayElements(
-        static_cast<jcharArray>(array), native_ptr, copy_back_mode);
+  bool constexpr operator==(
+      const ClassLoader<ParentLoader_, SupportedClasses_...>& rhs) const {
+    return (*this).parent_loader_ == rhs.parent_loader_ &&
+           (*this).supported_classes_ == rhs.supported_classes_;
   }
-};
-
-template <>
-struct JniArrayHelper<jshort, 1> : public JniArrayHelperBase {
-  using AsArrayType = jshortArray;
-
-  static inline jshortArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewShortArray(size);
+  template <typename T>
+  bool constexpr operator==(const T& rhs) const {
+    return false;
   }
-
-  static inline GetArrayElementsResult<jshort> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jshort> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetShortArrayElements(
-        static_cast<jshortArray>(array), &return_value.is_copy);
-    return return_value;
+  template <typename T>
+  bool constexpr operator!=(const T& rhs) const {
+    return !(*this == rhs);
   }
 
-  static inline void ReleaseArrayElements(jarray array, jshort* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseShortArrayElements(
-        static_cast<jshortArray>(array), native_ptr, copy_back_mode);
+  template <const auto& class_v, std::size_t... Is>
+  constexpr std::size_t IdxOfClassHelper(
+      std::integer_sequence<std::size_t, Is...>) const {
+    // std::max appears to be missing the initializer list overload in Bazel's
+    // implementation of clang.  This should simply be std::max.
+    return metaprogramming::ModifiedMax(
+        {((std::get<Is>(supported_classes_) == class_v)
+              ? std::size_t{Is}
+              : metaprogramming::kNegativeOne)...,
+         metaprogramming::kNegativeOne});
   }
-};
 
-template <>
-struct JniArrayHelper<jint, 1> : public JniArrayHelperBase {
-  using AsArrayType = jintArray;
+  // Returns the index for a given class within this set (any given class ref is
+  // defined by this index).
+  template <const auto& class_v>
+  constexpr std::size_t IdxOfClass() const {
+    return IdxOfClassHelper<class_v>(
+        std::make_integer_sequence<std::size_t,
+                                   sizeof...(SupportedClasses_)>());
+  }
 
-  static inline jintArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewIntArray(size);
+  // Tests if a class is supported by this class loader (not ancestors).
+  template <const auto& possibly_supported_class>
+  constexpr bool SupportedByThisSet() const {
+    return IdxOfClass<possibly_supported_class>() != kClassNotInLoaderSetIdx;
   }
 
-  static inline GetArrayElementsResult<jint> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jint> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetIntArrayElements(
-        static_cast<jintArray>(array), &return_value.is_copy);
-    return return_value;
+  // Tests if a class is supported by this class loader (ancestors included).
+  template <const auto& possibly_supported_class,
+            bool ignore_default_loader = false>
+  constexpr bool SupportedDirectlyOrIndirectly() const {
+    return parent_loader_.template SupportedDirectlyOrIndirectly<
+               possibly_supported_class>() ||
+           SupportedByThisSet<possibly_supported_class>();
   }
 
-  static inline void ReleaseArrayElements(jarray array, int* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseIntArrayElements(
-        static_cast<jintArray>(array), native_ptr, copy_back_mode);
+  // Returns the index for parent-most ancestor that supports a given class.
+  template <const auto& possibly_supported_class>
+  constexpr std::size_t IdxOfAncestor(std::size_t cur_idx = 0) const {
+    if (SupportedByThisSet<possibly_supported_class>() &&
+        !parent_loader_.template SupportedDirectlyOrIndirectly<
+            possibly_supported_class, true>()) {
+      return cur_idx;
+    }
+    return parent_loader_.template IdxOfAncestor<possibly_supported_class>(
+        cur_idx + 1);
   }
 };
 
-template <>
-struct JniArrayHelper<jlong, 1> : public JniArrayHelperBase {
-  using AsArrayType = jlongArray;
+// Note: Null is chosen, not default, because LoadedBy requires a syntax like
+// LoadedBy{ClassLoader{"kClass"}} (using the CTAD loader type below), but
+// we want to prevent explicit usage of a default loader (as it makes no sense).
+ClassLoader(const char*)
+    -> ClassLoader<std::decay_t<decltype(kNullClassLoader)>>;
 
-  static inline jlongArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewLongArray(size);
-  }
+template <typename ParentLoader_, typename... SupportedClasses_>
+ClassLoader(ParentLoader_ parent_loader,
+            SupportedClassSet<SupportedClasses_...> supported_classes)
+    -> ClassLoader<ParentLoader_, SupportedClasses_...>;
 
-  static inline GetArrayElementsResult<jlong> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jlong> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetLongArrayElements(
-        static_cast<jlongArray>(array), &return_value.is_copy);
-    return return_value;
+template <typename... SupportedClasses_>
+ClassLoader(SupportedClassSet<SupportedClasses_...>)
+    -> ClassLoader<DefaultClassLoader, SupportedClasses_...>;
+
+template <typename T, std::size_t I>
+constexpr auto& GetAncestor(const T& loader) {
+  if constexpr (I == 0) {
+    return loader;
+  } else {
+    return GetAncestor<decltype(loader.parent_loader_), I - 1>(
+        loader.parent_loader_);
   }
+}
 
-  static inline void ReleaseArrayElements(jarray array, jlong* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseLongArrayElements(
-        static_cast<jlongArray>(array), native_ptr, copy_back_mode);
+template <const auto& loader, const auto& possibly_supported_class>
+constexpr const auto& ParentLoaderForClass() {
+  if constexpr (!loader.template SupportedDirectlyOrIndirectly<
+                    possibly_supported_class>()) {
+    return kNullClassLoader;
+  } else if constexpr (loader.template IdxOfAncestor<
+                           possibly_supported_class>() !=
+                       kClassNotInLoaderSetIdx) {
+    return GetAncestor<
+        decltype(loader),
+        loader.template IdxOfAncestor<possibly_supported_class>()>(loader);
+  } else {
+    return kDefaultClassLoader;
   }
-};
+}
 
-template <>
-struct JniArrayHelper<jfloat, 1> : public JniArrayHelperBase {
-  using AsArrayType = jfloatArray;
+}  // namespace jni
 
-  static inline jfloatArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewFloatArray(size);
-  }
 
-  static inline GetArrayElementsResult<jfloat> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jfloat> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetFloatArrayElements(
-        static_cast<jfloatArray>(array), &return_value.is_copy);
-    return return_value;
-  }
+#include <cstddef>
+#include <utility>
 
-  static inline void ReleaseArrayElements(jarray array, jfloat* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseFloatArrayElements(
-        static_cast<jfloatArray>(array), native_ptr, copy_back_mode);
-  }
-};
-
-template <>
-struct JniArrayHelper<jdouble, 1> : public JniArrayHelperBase {
-  using AsArrayType = jdoubleArray;
-
-  static inline jdoubleArray NewArray(std::size_t size) {
-    return jni::JniEnv::GetEnv()->NewDoubleArray(size);
-  }
-
-  static inline GetArrayElementsResult<jdouble> GetArrayElements(jarray array) {
-    GetArrayElementsResult<jdouble> return_value;
-    return_value.ptr_ = jni::JniEnv::GetEnv()->GetDoubleArrayElements(
-        static_cast<jdoubleArray>(array), &return_value.is_copy);
-    return return_value;
-  }
-
-  static inline void ReleaseArrayElements(jarray array, jdouble* native_ptr,
-                                          bool copy_on_completion) {
-    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
-    jni::JniEnv::GetEnv()->ReleaseDoubleArrayElements(
-        static_cast<jdoubleArray>(array), native_ptr, copy_back_mode);
-  }
-};
-
-// Note, this requires both a jclass and a sample jobject to build from which
-// is unlike any other new array construction.
-template <std::size_t kRank>
-struct JniArrayHelper<jobject, kRank> : public JniArrayHelperBase {
-  static inline jobjectArray NewArray(std::size_t size, jclass class_id,
-                                      jobject initial_element) {
-    return jni::JniEnv::GetEnv()->NewObjectArray(size, class_id,
-                                                 initial_element);
-  }
+namespace jni::metaprogramming {
 
-  // The API of fetching objects only permits accessing one object at a time.
-  static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
-    return jni::JniEnv::GetEnv()->GetObjectArrayElement(array, idx);
+// Performs a deep equality comparison of T, but is leniant about containers.
+// Returns true iff types are equal or both types are containers and their
+// non-type template parameters are equal.
+template <typename T>
+struct ValsEqual {
+  template <typename T1, typename T2, typename Enable = void>
+  struct Helper {
+    static constexpr bool val = std::is_same_v<T1, T2>;
   };
 
-  // The API of fetching objects only permits accessing one object at a time.
-  static inline void SetArrayElement(jobjectArray array, std::size_t idx,
-                                     jobject obj) {
-    jni::JniEnv::GetEnv()->SetObjectArrayElement(array, idx, obj);
+  // Value comparison.
+  template <template <const auto...> class Container1, const auto... V1s_,
+            template <const auto...> class Container2, const auto... V2s_>
+  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
+                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
+    static constexpr bool val = true;
   };
-};
 
-}  // namespace jni
+  // LHS l-reference, RHS value.
+  template <template <const auto&...> class Container1, const auto&... V1s_,
+            template <const auto...> class Container2, const auto... V2s_>
+  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
+                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
+    static constexpr bool val = true;
+  };
 
-#include <string_view>
-#include <type_traits>
+  // LHS value, RHS l-reference.
+  template <template <const auto...> class Container1, const auto... V1s_,
+            template <const auto&...> class Container2, const auto&... V2s_>
+  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
+                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
+    static constexpr bool val = true;
+  };
 
-namespace jni {
+  // RHS l-reference, RHS l-reference.
+  template <template <const auto&...> class Container1, const auto&... V1s_,
+            template <const auto&...> class Container2, const auto&... V2s_>
+  struct Helper<Container1<V1s_...>, Container2<V2s_...>,
+                std::enable_if_t<((V1s_ == V2s_) && ...)>> {
+    static constexpr bool val = true;
+  };
 
-// Metafunction that returns either "" if a member called |name_| isn't
-// present, or a constexpr std::string_view of the name if it is.
-template <const auto&, typename Enable = void>
-struct NameOrNothing {
-  static constexpr std::string_view val{""};
+  template <typename T2>
+  static constexpr bool val = Helper<T, T2>::val;
 };
 
-template <const auto& val_>
-struct NameOrNothing<val_, std::void_t<decltype(val_.name_)>> {
-  static constexpr std::string_view val{val_.name_};
-};
+template <typename T1, typename T2>
+static constexpr bool ValsEqual_v = ValsEqual<T1>::template val<T2>;
 
-template <const auto& val>
-static constexpr auto NameOrNothing_v = NameOrNothing<val>::val;
+template <auto V1, auto V2>
+static constexpr bool ValsEqual_v_v =
+    ValsEqual<Vals<V1>>::template val<Vals<V2>>;
 
-static constexpr std::string_view kInit{"<init>"};
+template <auto& V1, auto& V2>
+static constexpr bool ValsEqual_r_v =
+    ValsEqual<ValsRef<V1>>::template val<ValsRef<V2>>;
 
-}  // namespace jni
+template <const auto& V1, const auto& V2>
+static constexpr bool ValsEqual_cr_v =
+    ValsEqual<ValsConstRef<V1>>::template val<ValsConstRef<V2>>;
 
-namespace jni {
+}  // namespace jni::metaprogramming
 
-struct LoaderTag {};
+namespace jni::metaprogramming {
 
-// Annotation for use in function and field declarations. When used as argument
-// the underlying object must come from the same class loader.
-template <typename ClassLoaderT, typename ClassT>
-struct LoadedBy : LoaderTag {
-  const ClassLoaderT class_loader_;
-  const ClassT class_;
+// Builds a stable (i.e. first unique type is preserved) set of unique types
+// from a set.
+struct UniqueSet {
+  template <typename... Ts>
+  struct Helper {
+    using type = std::tuple<>;
+  };
 
-  static_assert(
-      !std::is_same_v<ClassLoaderT, ClassLoader<DefaultClassLoader>>,
-      "LoadedBy is not required for the default loader (it's implicit).");
+  template <typename... Ts>
+  using Helper_t = typename Helper<Ts...>::type;
 
-  constexpr LoadedBy(ClassLoaderT class_loader, ClassT clazz)
-      : class_loader_(class_loader), class_(clazz) {}
-};
+  // Strips the first element from the first set if it's not unique.
+  template <typename T, typename... Ts>
+  struct Helper<T, Ts...> {
+    using type =
+        std::conditional_t<!Contains_v<T, Ts...>,
+                           ConcatenateTup_t<std::tuple<T>, Helper_t<Ts...>>,
+                           Helper_t<Ts...>>;
+  };
 
-template <typename ClassLoaderT, typename ClassT>
-LoadedBy(ClassLoaderT, ClassT) -> LoadedBy<ClassLoaderT, ClassT>;
+  template <typename... Ts>
+  using InputSetReversed = Reverse_t<Ts...>;
 
-template <typename T>
-struct IsLoadedBy {
-  static constexpr bool val = false;
-};
+  template <typename... Ts>
+  using ReverseSetStrippedOfDuplicates =
+      typename TupleToType_t<InputSetReversed<Ts...>, Helper>::type;
 
-template <typename ClassLoaderT, typename ClassT>
-struct IsLoadedBy<LoadedBy<ClassLoaderT, ClassT>> {
-  static constexpr bool val = true;
+  template <typename... Ts>
+  using type = Reverse_Tup<ReverseSetStrippedOfDuplicates<Ts...>>;
 };
 
-template <typename T>
-static constexpr bool IsLoadedBy_v = IsLoadedBy<T>::val;
-
-template <typename T>
-constexpr auto StripClassFromLoadedBy(T val) {
-  if constexpr (IsLoadedBy_v<T>) {
-    return val.class_;
-  } else {
-    return val;
-  }
-}
+template <typename... Ts>
+using UniqueSet_t = typename UniqueSet::template type<Ts...>;
 
-template <typename T>
-constexpr auto StripClassLoaderFromLoadedBy(T val) {
-  if constexpr (IsLoadedBy_v<T>) {
-    return val.class_loader_;
-  } else {
-    return val;
-  }
-}
+template <typename Tup>
+using UniqueSet_Tup = TupleUnroller_t<UniqueSet, Tup>;
 
-}  // namespace jni
+}  // namespace jni::metaprogramming
 
 #include <tuple>
-#include <type_traits>
-#include <utility>
-
-namespace jni {
-
-template <typename... ClassLoaderTs>
-class Jvm {
- public:
-  const std::tuple<ClassLoaderTs...> class_loaders_;
 
-  constexpr Jvm(ClassLoaderTs... class_loaders)
-      : class_loaders_(class_loaders...) {}
+namespace jni::metaprogramming {
 
-  template <const auto& class_loader_v, std::size_t... Is>
-  constexpr size_t IdxOfClassLoaderHelper(
-      std::integer_sequence<std::size_t, Is...>) const {
-    return metaprogramming::ModifiedMax(
-        {((std::get<Is>(class_loaders_) == class_loader_v) ? Is : -1)...});
-  }
+// Metafunction that takes sets of tuples and reduces them to a single tuple.
+// No element in the result set will be a tuple, any and all nested tuples will
+// be flattened.
+struct Flatten {
+  template <typename... Ts>
+  struct FlattenHelper {
+    using type = std::tuple<>;
+  };
 
-  // Returns the index for a given classloader within this set (any given class
-  // ref is defined by this index).
-  template <const auto& class_loader_v>
-  constexpr size_t IdxOfClassLoader() const {
-    return IdxOfClassLoaderHelper<class_loader_v>(
-        std::make_integer_sequence<std::size_t, sizeof...(ClassLoaderTs)>());
-  }
+  template <typename... TupleContents, typename... Ts>
+  struct FlattenHelper<std::tuple<TupleContents...>, Ts...> {
+    // If the type itself is a tuple, it may itself contain nested tuples.
+    using type =
+        ConcatenateTup_t<typename FlattenHelper<TupleContents...>::type,
+                         typename FlattenHelper<Ts...>::type>;
+  };
 
-  template <typename T>
-  bool constexpr operator==(const T& rhs) const {
-    return false;
-  }
-  bool constexpr operator==(const Jvm&) const { return true; }
+  template <typename NonTupleType, typename... Ts>
+  struct FlattenHelper<NonTupleType, Ts...> {
+    // The first type is for certain not a tuple or the alternate specialisation
+    // would have been chosen. The value is wrapped back into a tuple, in order
+    // to exploit ConcatenateTup_t and potentially flatten any remaining args.
+    using type = ConcatenateTup_t<std::tuple<NonTupleType>,
+                                  typename FlattenHelper<Ts...>::type>;
+  };
 
-  template <typename T>
-  bool constexpr operator!=(const T& rhs) const {
-    return !(*this == rhs);
-  }
+  template <typename... Ts>
+  using type = typename FlattenHelper<Ts...>::type;
 };
 
-template <typename... ClassLoaderTs>
-Jvm(ClassLoaderTs...) -> Jvm<ClassLoaderTs...>;
+template <typename... Ts>
+using Flatten_t = typename Flatten::template type<Ts...>;
 
-// Convenience Jvm definition.
-// Compatible with default class loader or specified loaders.
-inline constexpr Jvm kDefaultJvm{kDefaultClassLoader};
+}  // namespace jni::metaprogramming
 
-}  // namespace jni
+#include <tuple>
+#include <type_traits>
+#include <utility>
 
-namespace jni {
+namespace jni::metaprogramming {
 
-enum class IdType {
-  CLASS,
-  STATIC_OVERLOAD_SET,
-  STATIC_OVERLOAD,
-  STATIC_OVERLOAD_PARAM,
-  OVERLOAD_SET,
-  OVERLOAD,
-  OVERLOAD_PARAM,
-  STATIC_FIELD,
-  FIELD,
-};
+// Metafunction that takes a list of tuples, and creates a counter where each
+// value is the size of the corresponding tuple.  This can be used to create
+// every possible permutation of the input tuples.
+struct GenerateBitSequenceFromTupSets {
+  template <typename... Tups>
+  struct Helper {
+    using ListOfTups = std::tuple<Tups...>;
 
-}  // namespace jni
+    template <typename>
+    struct SequenceGenerator {};
 
+    template <size_t... Is>
+    struct SequenceGenerator<std::index_sequence<Is...>> {
+      // Generates count to max size inclusive, so -1 on the size.
+      // e.g. std::tuple<int> has only 1 viable selection but would be
+      // represented by a unary NBit (i.e NBit<0, 0, false>);
+      using type =
+          NBitSequence<NBit<0,
+                            std::tuple_size_v<TypeOfNthTupleElement_t<
+                                Is, typename Helper<Tups...>::ListOfTups>> -
+                                1,
+                            false>...>;
+    };
+  };
 
-#include <tuple>
-#include <utility>
+  template <typename... Tups>
+  using type = typename Helper<Tups...>::template SequenceGenerator<
+      std::make_index_sequence<sizeof...(Tups)>>::type;
+};
 
-namespace jni::metaprogramming {
+struct GenerateBitSequenceFromTupSetsFunc {
+  template <typename... Tups>
+  using type = typename GenerateBitSequenceFromTupSets::template type<Tups...>;
+};
 
-// Metafunction to take a sequence of indices, and produce the corresponding
-// elements in sequences of tuples.
-template <std::size_t... sizes>
-struct TypeIndexMask {
-  template <typename, typename... Ts>
-  struct GetHelper {};
+template <typename... Tups>
+using GenerateBitSequenceFromTupSets_t =
+    typename GenerateBitSequenceFromTupSets::template type<Tups...>;
 
-  template <std::size_t... Is, typename... Ts>
-  struct GetHelper<std::index_sequence<Is...>, Ts...> {
-    using type = std::tuple<TypeOfNthTupleElement_t<Is, Ts>...>;
-  };
+struct CartesianProduct {
+  template <typename... Tups>
+  struct CartesianProductHelper {
+    using NBitSequenceForTups = GenerateBitSequenceFromTupSets_t<Tups...>;
+    using AllTupsAsList = std::tuple<Tups...>;
 
-  template <typename... Ts>
-  using Get = typename GetHelper<std::index_sequence<sizes...>, Ts...>::type;
+    template <typename>
+    struct SequenceGenerator {};
 
-  template <typename>
-  struct SequenceGenerator {};
+    template <size_t... Is>
+    struct SequenceGenerator<std::index_sequence<Is...>> {
+      using type = std::tuple<typename Increment_t<
+          NBitSequenceForTups, Is>::TypeMask::template type<AllTupsAsList>...>;
+    };
 
-  template <typename... Ts>
-  struct SequenceGenerator<std::tuple<Ts...>> {
-    using type = Get<Ts...>;
+    using type = typename SequenceGenerator<std::make_index_sequence<
+        NBitSequenceForTups::max_representable_size_>>::type;
   };
 
-  template <typename Tup>
-  using type = typename SequenceGenerator<Tup>::type;
+  template <>
+  struct CartesianProductHelper<> {
+    using type = std::tuple<>;
+  };
+
+  template <typename... Tups>
+  using type = typename CartesianProductHelper<Tups...>::type;
 };
 
-template <typename TupOfTypes, std::size_t... sizes>
-using TypeTupFromIndexMask_t =
-    typename TypeIndexMask<sizes...>::template type<TupOfTypes>;
+template <typename... Tups>
+using CartesianProduct_t = typename CartesianProduct::template type<Tups...>;
 
 }  // namespace jni::metaprogramming
 
 
-#include <algorithm>
-#include <utility>
+namespace jni {
 
-namespace jni::metaprogramming {
+// jobject.
+template <>
+struct LifecycleHelper<jobject, LifecycleType::LOCAL>
+    : public LifecycleLocalBase<jobject> {
+  template <typename... CtorArgs>
+  static inline jobject Construct(jclass clazz, jmethodID ctor_method,
+                                  CtorArgs&&... ctor_args) {
+    return JniEnv::GetEnv()->NewObject(clazz, ctor_method, ctor_args...);
+  }
+};
 
-// Represents a value that can be [0, max], and an overflow bit.
-// When incremented, the type will rollover, and set its overflow bit.
-template <size_t cur_value, size_t max = 1, bool overflow_bit = false>
-struct NBit {
-  static constexpr size_t value_ = cur_value;
-  static constexpr size_t overflow_bit_ = overflow_bit;
+template <>
+struct LifecycleHelper<jobject, LifecycleType::GLOBAL>
+    : public LifecycleGlobalBase<jobject> {
+  template <typename... CtorArgs>
+  static inline jobject Construct(jclass clazz, jmethodID ctor_method,
+                                  CtorArgs&&... ctor_args) {
+    using Local = LifecycleHelper<jobject, LifecycleType::LOCAL>;
 
-  // Only unary values will ever need the clamp.
-  using Increment =
-      NBit<(value_ == max ? 0 : std::clamp(value_ + 1, size_t{0}, max)), max,
-           value_ == max>;
+    jobject local_object = Local::Construct(
+        clazz, ctor_method, std::forward<CtorArgs&&>(ctor_args)...);
+    jobject global_object = Promote(local_object);
+    Local::Delete(local_object);
 
-  using ResetOverflow = NBit<cur_value, max, false>;
+    return global_object;
+  }
 };
 
-}  // namespace jni::metaprogramming
+// jclass.
+template <>
+struct LifecycleHelper<jclass, LifecycleType::LOCAL>
+    : public LifecycleLocalBase<jclass> {};
 
+template <>
+struct LifecycleHelper<jclass, LifecycleType::GLOBAL>
+    : public LifecycleGlobalBase<jclass> {};
 
-#include <type_traits>
-#include <utility>
+}  // namespace jni
 
-namespace jni::metaprogramming {
+#include <optional>
 
-// Metafunction to increment types a certain number of times.
-// Types must export a type alias "Increment" which increments the type once.
-template <std::size_t I>
-struct Increment {
-  template <typename T, std::size_t Idx>
-  struct IncrementCountHelper {
-    using type = typename Increment<Idx - 1>::template type<T>::Increment;
-  };
+namespace jni {
 
-  template <typename T>
-  struct IncrementCountHelper<T, 0> {
-    using type = T;
-  };
+// Used to detect RefBase in type proxying.
+// This is useful, e.g. when you want to say "an object that might be passed"
+// but the object's type (i.e. full name + loader information) is unknown.
+template <typename StorageType>
+class RefBaseTag {
+ public:
+  RefBaseTag(StorageType object) : object_ref_(object) {}
 
-  template <typename T>
-  using type = typename IncrementCountHelper<T, I>::type;
-};
+  RefBaseTag(const RefBaseTag& rhs) = delete;
 
-template <typename T, std::size_t I = 1>
-using Increment_t = typename Increment<I>::template type<T>;
+  RefBaseTag(RefBaseTag&& rhs) {
+    object_ref_ = rhs.object_ref_;
+    rhs.object_ref_ = nullptr;
+  }
 
-}  // namespace jni::metaprogramming
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, StorageType>>>
+  RefBaseTag(RefBaseTag<T>&& rhs) : object_ref_(rhs.Release()) {}
+
+  StorageType Release() {
+    StorageType return_value = object_ref_;
+    object_ref_ = nullptr;
 
+    return return_value;
+  }
 
-#include <mutex>
-#include <atomic>
-#include <functional>
+  explicit operator StorageType() const { return object_ref_; }
 
-namespace jni::metaprogramming {
+ protected:
+  StorageType object_ref_ = nullptr;
+};
 
-// This class is intended to mimic a function local static except that it
-// supports being reset. The object is constructed with a lambda and all
-// subsequent loads will be thread safe, invoking the lambda once (and only
-// once) if the currently stored value is T{0}.
+// Represents a runtime object with only Name information.  It is ephemeral and
+// can be used a return value which is immediately wrapped in a rich object type
+// (such as LocalObject, LocalString) which has the complete class definition.
 //
-// This class is thread-safe.  Loads will be cheap (after a potentially
-// expensive initial init), stores are expensive.
-template<typename T_>
-class DoubleLockedValue {
+// This can also be used as a temporary when passed into a function that accepts
+// objects.  This ensures type correctness (names must match) but doesn't
+// require the full class description be used when describing the function.
+template <typename JniT>
+class RefBase : public RefBaseTag<typename JniT::StorageType> {
  public:
-  template <typename Lambda>
-  inline T_ LoadAndMaybeInit(Lambda lambda) {
-    // Typical case, value already initialised, perform cheap load and return.
-    T_ return_value = value_.load(std::memory_order_acquire);
+  using StorageType = typename JniT::StorageType;
+  using RefBaseTag<StorageType>::RefBaseTag;
+  using RefBaseTag<StorageType>::operator typename JniT::StorageType;
 
-    if(return_value != T_{0}) {
-      return return_value;
-    }
+  static inline const char* name_ = JniT::class_v.name_;
 
-    // Value was nil (uninitialised), perform heavy-weight lock.
-    std::lock_guard<std::mutex> lock_guard {lock_};
+  RefBase(const RefBase& rhs) = delete;
 
-    // Check another thread didn't race to lock before.
-    return_value = value_.load(std::memory_order_acquire);
-    if(return_value != T_{}) {
-      return return_value;
-    }
+  RefBase(RefBaseTag<StorageType>&& rhs)
+      : RefBaseTag<StorageType>(std::move(rhs)) {}
+};
 
-    // Perform the potentially expensive initialisation and return.
-    return_value = lambda();
-    value_.store(return_value, std::memory_order_release);
-    return return_value;
-  }
+//==============================================================================
+template <typename T>
+using RefBaseT_t = typename T::RefBaseT;
 
-  // Sets the value to {0}.
-  inline void Reset() {
-    std::lock_guard<std::mutex> lock_guard {lock_};
-    value_.store(0, std::memory_order_release);
-  }
+}  // namespace jni
 
-  // Sets the value to {0} and iff the value was not {0} prior to being torn
-  // down, the teardown lambda will be invoked with this value.
-  template <typename TeardownLambda>
-  inline void Reset(TeardownLambda lambda) {
-    std::lock_guard<std::mutex> lock_guard {lock_};
-    auto val = value_.load();
-    if(val != 0) {
-      lambda(val);
-      value_.store(0, std::memory_order_release);
-    }
-  }
 
- private:
-  std::atomic<T_> value_ = {0};
-  std::mutex lock_;
-};
+namespace jni {
 
-}  // namespace jni::metaprogramming
+struct LoaderTag {};
 
-#include <tuple>
-#include <type_traits>
-
-namespace jni::metaprogramming {
-
-// Metafunction that detects a partial specialisation for a Container.
-template <template <typename> class Container>
-struct Detect {
-  template <typename T, typename Enable = void>
-  struct Helper {
-    static constexpr bool val = false;
-    using type = std::tuple<>;
-  };
-
-  template <typename T>
-  struct Helper<T, std::void_t<typename Container<T>::type>> {
-    static constexpr bool val = true;
-    using type = typename Container<T>::type;
-  };
+// Annotation for use in function and field declarations. When used as argument
+// the underlying object must come from the same class loader.
+template <typename ClassLoaderT, typename ClassT>
+struct LoadedBy : LoaderTag {
+  const ClassLoaderT class_loader_;
+  const ClassT class_;
 
-  template <typename T>
-  using type = typename Helper<T>::type;
+  static_assert(
+      !std::is_same_v<ClassLoaderT, ClassLoader<DefaultClassLoader>>,
+      "LoadedBy is not required for the default loader (it's implicit).");
 
-  template <typename T>
-  static constexpr bool val = Helper<T>::val;
+  constexpr LoadedBy(ClassLoaderT class_loader, ClassT clazz)
+      : class_loader_(class_loader), class_(clazz) {}
 };
 
-template <template <typename> class Container, typename T>
-using Detect_t = typename Detect<Container>::template type<T>;
-
-template <template <typename> class Container, typename T>
-static constexpr bool Detect_v = Detect<Container>::template val<T>;
-
-}  // namespace jni::metaprogramming
+template <typename ClassLoaderT, typename ClassT>
+LoadedBy(ClassLoaderT, ClassT) -> LoadedBy<ClassLoaderT, ClassT>;
 
-namespace jni {
+template <typename T>
+struct IsLoadedBy {
+  static constexpr bool val = false;
+};
 
-template <>
-struct LifecycleHelper<jstring, LifecycleType::LOCAL>
-    : public LifecycleLocalBase<jstring> {
-  static inline jstring Construct(const char* chars) {
-    return jni::JniEnv::GetEnv()->NewStringUTF(chars);
-  }
+template <typename ClassLoaderT, typename ClassT>
+struct IsLoadedBy<LoadedBy<ClassLoaderT, ClassT>> {
+  static constexpr bool val = true;
 };
 
-template <>
-struct LifecycleHelper<jstring, LifecycleType::GLOBAL>
-    : public LifecycleGlobalBase<jstring> {
-  template <typename... CtorArgs>
-  static inline jstring Construct(const char* chars) {
-    using Local = LifecycleHelper<jstring, LifecycleType::LOCAL>;
+template <typename T>
+static constexpr bool IsLoadedBy_v = IsLoadedBy<T>::val;
 
-    jstring local_string = Local::Construct(chars);
-    jstring global_string = Promote(local_string);
-    Local::Delete(local_string);
+template <typename T>
+constexpr auto StripClassFromLoadedBy(T val) {
+  if constexpr (IsLoadedBy_v<T>) {
+    return val.class_;
+  } else {
+    return val;
+  }
+}
 
-    return global_string;
+template <typename T>
+constexpr auto StripClassLoaderFromLoadedBy(T val) {
+  if constexpr (IsLoadedBy_v<T>) {
+    return val.class_loader_;
+  } else {
+    return val;
   }
-};
+}
 
 }  // namespace jni
 
+#include <tuple>
+#include <type_traits>
 #include <utility>
 
 namespace jni {
 
-template <typename ReturnType, std::size_t kRank, bool kStatic>
-class InvokeHelper {};
+template <typename... ClassLoaderTs>
+class Jvm {
+ public:
+  const std::tuple<ClassLoaderTs...> class_loaders_;
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0 type: void
-//    void is special, but for symmetry it uses rank 0 with primitives.
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct InvokeHelper<void, 0, false> {
-  template <typename... Ts>
-  static void Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
-    jni::JniEnv::GetEnv()->CallVoidMethod(object, method_id,
-                                          std::forward<Ts>(ts)...);
-  }
-};
+  constexpr Jvm(ClassLoaderTs... class_loaders)
+      : class_loaders_(class_loaders...) {}
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0 types, i.e. the primitive type itself (e.g. int).
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct InvokeHelper<jboolean, 0, false> {
-  template <typename... Ts>
-  static jboolean Invoke(jobject object, jclass, jmethodID method_id,
-                         Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallBooleanMethod(object, method_id,
-                                                    std::forward<Ts>(ts)...);
+  template <const auto& class_loader_v, std::size_t... Is>
+  constexpr size_t IdxOfClassLoaderHelper(
+      std::integer_sequence<std::size_t, Is...>) const {
+    return metaprogramming::ModifiedMax(
+        {((std::get<Is>(class_loaders_) == class_loader_v) ? Is : -1)...});
   }
-};
 
-template <>
-struct InvokeHelper<jint, 0, false> {
-  template <typename... Ts>
-  static jint Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallIntMethod(object, method_id,
-                                                std::forward<Ts>(ts)...);
+  // Returns the index for a given classloader within this set (any given class
+  // ref is defined by this index).
+  template <const auto& class_loader_v>
+  constexpr size_t IdxOfClassLoader() const {
+    return IdxOfClassLoaderHelper<class_loader_v>(
+        std::make_integer_sequence<std::size_t, sizeof...(ClassLoaderTs)>());
   }
-};
 
-template <>
-struct InvokeHelper<jlong, 0, false> {
-  template <typename... Ts>
-  static jlong Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallLongMethod(object, method_id,
-                                                 std::forward<Ts>(ts)...);
+  template <typename T>
+  bool constexpr operator==(const T& rhs) const {
+    return false;
   }
-};
+  bool constexpr operator==(const Jvm&) const { return true; }
 
-template <>
-struct InvokeHelper<jfloat, 0, false> {
-  template <typename... Ts>
-  static jfloat Invoke(jobject object, jclass, jmethodID method_id,
-                       Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallFloatMethod(object, method_id,
-                                                  std::forward<Ts>(ts)...);
+  template <typename T>
+  bool constexpr operator!=(const T& rhs) const {
+    return !(*this == rhs);
   }
 };
 
-template <>
-struct InvokeHelper<jdouble, 0, false> {
-  template <typename... Ts>
-  static jdouble Invoke(jobject object, jclass, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallDoubleMethod(object, method_id,
-                                                   std::forward<Ts>(ts)...);
-  }
-};
+template <typename... ClassLoaderTs>
+Jvm(ClassLoaderTs...) -> Jvm<ClassLoaderTs...>;
 
-template <>
-struct InvokeHelper<jobject, 0, false> {
-  // This always returns a local reference which should be embedded in type
-  // information wherever this is used.
-  template <typename... Ts>
-  static jobject Invoke(jobject object, jclass, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallObjectMethod(object, method_id,
-                                                   std::forward<Ts>(ts)...);
-  }
-};
+// Convenience Jvm definition.
+// Compatible with default class loader or specified loaders.
+inline constexpr Jvm kDefaultJvm{kDefaultClassLoader};
 
-template <>
-struct InvokeHelper<jstring, 0, false> {
-  template <typename... Ts>
-  static jobject Invoke(jobject object, jclass, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallObjectMethod(object, method_id,
-                                                   std::forward<Ts>(ts)...);
-  }
-};
+}  // namespace jni
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1 types, i.e. single dimension arrays (e.g. int[]).
-////////////////////////////////////////////////////////////////////////////////
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, false> {
-  template <typename... Ts>
-  static jbooleanArray Invoke(jobject object, jclass, jmethodID method_id,
-                              Ts&&... ts) {
-    return static_cast<jbooleanArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
+#include <cstddef>
+#include <limits>
+#include <string_view>
+#include <utility>
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, false> {
-  template <typename... Ts>
-  static jbyteArray Invoke(jobject object, jclass, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jbyteArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
+namespace jni {
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, false> {
-  template <typename... Ts>
-  static jcharArray Invoke(jobject object, jclass, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jcharArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
+template <typename JniT_, IdType kIdType_, std::size_t idx = kNoIdx,
+          std::size_t secondary_idx = kNoIdx, std::size_t tertiary_idx = kNoIdx>
+struct Id {
+  using JniT = JniT_;
+  static constexpr IdType kIdType = kIdType_;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, false> {
-  template <typename... Ts>
-  static jshortArray Invoke(jobject object, jclass, jmethodID method_id,
-                            Ts&&... ts) {
-    return static_cast<jshortArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
+  static constexpr auto Class() { return JniT::GetClass(); }
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, false> {
-  template <typename... Ts>
-  static jintArray Invoke(jobject object, jclass, jmethodID method_id,
-                          Ts&&... ts) {
-    return static_cast<jintArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
+  static constexpr std::size_t kIdx = idx;
+  static constexpr std::size_t kSecondaryIdx = secondary_idx;
+  static constexpr std::size_t kTertiaryIdx = tertiary_idx;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, false> {
-  template <typename... Ts>
-  static jlongArray Invoke(jobject object, jclass, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jlongArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, false> {
-  template <typename... Ts>
-  static jfloatArray Invoke(jobject object, jclass, jmethodID method_id,
-                            Ts&&... ts) {
-    return static_cast<jfloatArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, false> {
-  template <typename... Ts>
-  static jdoubleArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jdoubleArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, false> {
-  // Arrays of arrays (which this invoke represents) return object arrays
-  // (arrays themselves are objects, ergo object arrays).
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Rank 2+ types, i.e. multi-dimension arrays (e.g. int[][], int[][][]).
-////////////////////////////////////////////////////////////////////////////////
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, false> {
-  // Arrays of arrays (which this invoke represents) return object arrays
-  // (arrays themselves are objects, ergo object arrays).
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, false> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
-        object, method_id, std::forward<Ts>(ts)...));
-  }
-};
-
-}  // namespace jni
-
-#include <string_view>
-
-namespace jni {
-
-// Helper to generate full signature information for a "selected" value, and
-// possibly some container information.  Here, |Selector| is |MethodSelection|,
-// |FieldSelection|, etc.
-//
-// Unfortunately, the type system does not permit passing subobjects, however,
-// types can be used that represent a specific selection upon an object.  This
-// consolidates all signature info.
-//
-// |Selector| must express a type alias for RawVal (e.g. jint, Class{...}, etc.)
-// and a type alias |RawValT| which is std::decay_t<RawVal>;
-template <typename Selector>
-struct SelectorStaticInfo {
-  template <std::size_t I>
-  struct IthRawTypeMember {
-    template <typename T>
-    static constexpr const auto& Val(const T& val) {
-      return IthRawTypeMember<I - 1>::Val(val.raw_);
-    }
-  };
-
-  template <>
-  struct IthRawTypeMember<0> {
-    template <typename T>
-    static constexpr const auto& Val(const T& val) {
-      return val;
-    }
-  };
-
-  // Strangely, the compiler refuses to peer through Val and loses the
-  // constexpr-ness (i.e std::decay_t<decltype(Val())>; is not a constant
-  // expression).
-  static constexpr inline auto Val() {
-    if constexpr (Selector::kRank == 0) {
-      return Selector::Val();
-    } else {
-      return Selector::Val().raw_;
-    }
-  }
-
-  using RawValT = typename Selector::RawValT;
-
-  static constexpr inline bool kIsObject = std::is_base_of_v<Object, RawValT>;
-  static constexpr inline bool kIsVoid = std::is_same_v<Void, RawValT>;
-  static constexpr std::size_t kRank = Selector::kRank;
-
-  static constexpr std::string_view TypeNameOrNothingIfNotAnObject() {
-    if constexpr (kIsObject) {
-      return Val().name_;
-    } else {
-      return "";
-    }
-  }
-
-  static constexpr std::string_view kTypeNameOrNothingIfNotAnObject =
-      TypeNameOrNothingIfNotAnObject();
-
-  static constexpr std::string_view kEmptyStr = "";
-  static constexpr std::string_view kModifierStr =
-      (kRank == 0) ? ""
-                   : metaprogramming::RepeatString_v<
-                         kRank, metaprogramming::Constants::left_bracket>;
-
-  static constexpr std::string_view UndecoratedTypeName() {
-    if constexpr (kIsObject) {
-      return metaprogramming::StringConcatenate_v<
-          metaprogramming::Constants::L, kTypeNameOrNothingIfNotAnObject,
-          metaprogramming::Constants::semi_colon>;
-    } else if constexpr (kIsVoid) {
-      return JavaTypeToString<void>();
-    } else {
-      return JavaTypeToString<RawValT>();
-    }
-  }
-
-  static constexpr std::string_view kUndecoratedTypeName =
-      UndecoratedTypeName();
-
-  static constexpr std::string_view TypeName() {
-    return metaprogramming::StringConcatenate_v<kModifierStr,
-                                                kUndecoratedTypeName>;
-  }
-
-  static constexpr std::string_view kTypeName = TypeName();
-};
-
-}  // namespace jni
-
-#include <optional>
-
-namespace jni {
-
-// Used to detect RefBase in type proxying.
-// This is useful, e.g. when you want to say "an object that might be passed"
-// but the object's type (i.e. full name + loader information) is unknown.
-template <typename StorageType>
-class RefBaseTag {
- public:
-  RefBaseTag(StorageType object) : object_ref_(object) {}
-  RefBaseTag(RefBaseTag&& rhs) : object_ref_(rhs.Release()) {}
-
-  StorageType Release() {
-    StorageType return_value = object_ref_;
-    object_ref_ = nullptr;
-
-    return return_value;
-  }
-
-  explicit operator StorageType() const { return object_ref_; }
-
- protected:
-  StorageType object_ref_ = nullptr;
-};
-
-// Represents a runtime object with only Name information.  It is ephemeral and
-// can be used a return value which is immediately wrapped in a rich object type
-// (such as LocalObject, LocalString) which has the complete class definition.
-//
-// This can also be used as a temporary when passed into a function that accepts
-// objects.  This ensures type correctness (names must match) but doesn't
-// require the full class description be used when describing the function.
-template <typename JniT>
-class RefBase : public RefBaseTag<typename JniT::StorageType> {
- public:
-  using StorageType = typename JniT::StorageType;
-  using RefBaseTag<StorageType>::RefBaseTag;
-  using RefBaseTag<StorageType>::operator typename JniT::StorageType;
-
-  static inline const char* name_ = JniT::class_v.name_;
-
-  RefBase(RefBaseTag<StorageType>&& rhs)
-      : RefBaseTag<StorageType>(std::move(rhs)) {}
-  RefBase(RefBase&&) = default;
-};
-
-//==============================================================================
-template <typename T>
-using RefBaseT_t = typename T::RefBaseT;
-
-}  // namespace jni
-
-
-#include <type_traits>
-
-namespace jni {
-
-template <typename TUndecayed>
-struct ProxyHelper;
-
-// See jni::Proxy.
-template <typename T>
-using Proxy_t = typename ProxyHelper<T>::Proxy_t;
-
-template <typename T>
-using Index_t = typename ProxyHelper<T>::Index;
-
-template <typename T>
-using CDecl_t = typename ProxyHelper<T>::CDecl;
-
-template <typename T, typename Id>
-using Return_t = typename ProxyHelper<T>::template AsReturn_t<Id>;
-
-template <typename T, typename ParamSelection>
-using Arg_t = typename ProxyHelper<T>::template AsArg_t<ParamSelection>;
-
-template <typename T>
-using AsDecl_t = typename ProxyHelper<T>::AsDecl_t;
-
-// Instead of directly searching for the type, convertible types are sought.
-// E.g. A string like "Foo" the type will be const char[4] not const char*.
-template <typename Query>
-struct IsConvertibleKey {
-  template <typename T>
-  static constexpr bool value =
-      std::is_same_v<Query, std::decay_t<T>> ||
-      std::is_base_of_v<std::decay_t<T>, std::decay_t<Query>> ||
-      std::is_base_of_v<std::decay_t<Query>, std::decay_t<T>>;
-};
-
-template <typename Query, typename T>
-static constexpr bool IsConvertibleKey_v =
-    IsConvertibleKey<Query>::template value<T>;
-
-}  // namespace jni
+  static constexpr bool kIsConstructor =
+      (kIdType == IdType::OVERLOAD || kIdType == IdType::OVERLOAD_PARAM ||
+       kIdType == IdType::OVERLOAD_SET) &&
+      (kIdx == kNoIdx);
 
-#include <type_traits>
-#include <variant>
+  static constexpr bool kIsStatic = kIdType == IdType::STATIC_OVERLOAD_SET ||
+                                    kIdType == IdType::STATIC_OVERLOAD ||
+                                    kIdType == IdType::STATIC_OVERLOAD_PARAM ||
+                                    kIdType == IdType::STATIC_FIELD;
 
-namespace jni {
+  template <IdType new_id_type>
+  using ChangeIdType = Id<JniT, new_id_type, idx, secondary_idx, tertiary_idx>;
 
-template <typename SpanType_, const auto& class_v_,
-          const auto& class_loader_v_ = kDefaultClassLoader,
-          const auto& jvm_v_ = kDefaultJvm, std::size_t kRank_ = 0,
-          std::size_t class_idx_ = kNoIdx,
-          std::size_t class_loader_idx_ = kNoIdx>
-struct JniT {
-  static constexpr std::size_t kRank = kRank_;
+  template <std::size_t kIdxToChange, std::size_t kNewValue>
+  using ChangeIdx = Id<JniT, kIdType, (kIdxToChange == 0 ? kNewValue : idx),
+                       (kIdxToChange == 1 ? kNewValue : secondary_idx),
+                       (kIdxToChange == 2 ? kNewValue : tertiary_idx)>;
 
-  static constexpr bool MinimallySpecified() {
-    return (class_v_ == kNoClassSpecified
-                ? true
-                : (class_idx_ == kNoIdx ? true : false)) &&
-           (class_loader_v_ == kDefaultClassLoader
-                ? true
-                : (class_loader_idx_ == kNoIdx ? true : false));
-  }
+  static constexpr auto Val() {
+    if constexpr (kIdType == IdType::CLASS) {
+      return Class();
+    } else if constexpr (kIdType == IdType::STATIC_FIELD) {
+      static_assert(idx != kNoIdx);
+      return std::get<idx>(Class().static_.fields_).raw_;
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
+      // Overload (no such thing as static constructor).
+      static_assert(idx != kNoIdx);
+      return std::get<idx>(Class().static_.methods_);
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
+      // Overload (no such thing as static constructor).
+      static_assert(idx != kNoIdx);
+      return std::get<secondary_idx>(
+          std::get<idx>(Class().static_.methods_).invocations_);
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_PARAM) {
+      // Overload.
+      if constexpr (tertiary_idx == kNoIdx) {
+        // Return.
+        return std::get<secondary_idx>(
+                   std::get<idx>(Class().static_.methods_).invocations_)
+            .return_.raw_;
+      } else {
+        return std::get<tertiary_idx>(
+            std::get<secondary_idx>(
+                std::get<idx>(Class().static_.methods_).invocations_)
+                .params_.values_);
+      }
+    } else if constexpr (kIdType == IdType::OVERLOAD_SET) {
+      if constexpr (idx == kNoIdx) {
+        // Constructor.
+        return Class().constructors_;
+      } else {
+        // Overload.
+        return std::get<idx>(Class().methods_);
+      }
+    } else if constexpr (kIdType == IdType::OVERLOAD) {
+      if constexpr (idx == kNoIdx) {
+        // Constructor.
+        return std::get<secondary_idx>(Class().constructors_);
+      } else {
+        // Overload.
+        return std::get<secondary_idx>(
+            std::get<idx>(Class().methods_).invocations_);
+      }
+    } else if constexpr (kIdType == IdType::OVERLOAD_PARAM) {
+      if constexpr (idx == kNoIdx) {
+        // Constructor.
+        if constexpr (tertiary_idx == kNoIdx) {
+          // Return.
+          return Class();
+        } else {
+          // Overload return.
+          return std::get<tertiary_idx>(
+              std::get<secondary_idx>(Class().constructors_).params_.values_);
+        }
+      } else {
+        // Overload.
+        if constexpr (tertiary_idx == kNoIdx) {
+          // Return.
+          return std::get<secondary_idx>(
+                     std::get<idx>(Class().methods_).invocations_)
+              .return_.raw_;
+        } else {
+          return std::get<tertiary_idx>(
+              std::get<secondary_idx>(
+                  std::get<idx>(Class().methods_).invocations_)
+                  .params_.values_);
+        }
+      }
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
+      // Overload (no static_assert).
+      static_assert(idx != kNoIdx);
 
-  static constexpr auto GetClass() {
-    if constexpr (class_idx_ != kNoIdx) {
-      return StripClassFromLoadedBy(
-          std::get<class_idx_>(GetClassLoader().supported_classes_));
-    } else {
-      return StripClassFromLoadedBy(class_v_);
+      return std::get<secondary_idx>(
+          std::get<idx>(Class().static_methods_).invocations_);
+    } else if constexpr (kIdType == IdType::FIELD) {
+      static_assert(idx != kNoIdx);
+      return std::get<idx>(Class().fields_).raw_;
     }
   }
 
-  static constexpr auto GetClassLoader() {
-    if constexpr (class_loader_idx_ != kNoIdx) {
-      return StripClassLoaderFromLoadedBy(
-          std::get<class_loader_idx_>(jvm_v_.class_loaders_));
+  // Returns root for constructor, else return's "raw_" member.
+  static constexpr auto Materialize() {
+    if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
+      return Val().return_.raw_;
+    } else if constexpr (kIdType == IdType::OVERLOAD) {
+      if constexpr (kIdx == kNoIdx) {
+        // Constructor.
+        return Class();
+      } else {
+        // Overload return value.
+        return Val().return_.raw_;
+      }
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET ||
+                         kIdType == IdType::OVERLOAD_SET) {
+      // Not implemented.
+      return Void{};
     } else {
-      return StripClassLoaderFromLoadedBy(class_loader_v_);
+      return Val();
     }
   }
 
-  static constexpr std::string_view kName{GetClass().name_};
-  static constexpr std::string_view kNameWithDots{
-      metaprogramming::Replace_v<kName, '/', '.'>};
-
-  static constexpr const auto& GetJvm() { return jvm_v_; }
-
-  static constexpr auto GetStatic() {
-    return FullArrayStripV(GetClass()).static_;
-  }
-
-  static constexpr decltype(GetClass()) class_v = GetClass();
-  static constexpr decltype(GetClassLoader()) class_loader_v = GetClassLoader();
-  static constexpr decltype(jvm_v_) jvm_v = jvm_v_;
-  static constexpr decltype(GetStatic()) static_v = GetStatic();
-
-  using SpanType = SpanType_;
-  using StorageType = typename StorageHelper<SpanType_, kRank>::type;
-
-  using ClassT = std::decay_t<ArrayStrip_t<std::decay_t<decltype(GetClass())>>>;
-  using ClassLoaderT = std::decay_t<decltype(GetClassLoader())>;
-  using JvmT = std::decay_t<decltype(jvm_v)>;
-  using StaticT = std::decay_t<decltype(GetStatic())>;
-
-  static constexpr ClassT stripped_class_v{FullArrayStripV(GetClass())};
-
-  ////////////////////////////////////////////////////////////////////////////
-  // Minimal Spanning type (allows perfect cacheing for fully specified jvm).
-  ////////////////////////////////////////////////////////////////////////////
+  using MaterializeT = std::decay_t<decltype(Materialize())>;
+  using RawMaterializeT = ArrayStrip_t<MaterializeT>;
+  static constexpr std::size_t kMaterializedRank =
+      Rankifier::Rank(Materialize());
+  using MaterializeCDeclT = std::decay_t<VoidIfVoid_t<decltype(Materialize())>>;
 
-  // kNoIdx for default loader, then provided idx, then calculated idx.
-  static constexpr std::size_t MinimalClassIdx() {
-    if constexpr (class_idx_ != kNoIdx) {
-      // Fully specified (already).
-      return class_idx_;
-    } else if constexpr (class_loader_v_ == kDefaultClassLoader) {
-      // Partially specified.
-      return kNoIdx;
-    } else {
-      if constexpr (class_loader_v_.template IdxOfClass<class_v>() !=
-                    kClassNotInLoaderSetIdx) {
-        return class_loader_v_.template IdxOfClass<class_v>();
-      } else {
-        return kNoIdx;
-      }
-    }
-  }
+  using RawValT = ArrayStrip_t<std::decay_t<decltype(Val())>>;
+  using UnstrippedRawVal = std::decay_t<decltype(Val())>;
+  using CDecl = CDecl_t<VoidIfVoid_t<MaterializeT>>;
 
-  // kNoIdx for default jvm, then provided idx, then calculated idx.
-  static constexpr std::size_t MinimalClassLoaderIdx() {
-    // Fully specified (already).
-    if constexpr (class_loader_idx_ != kNoIdx) {
-      return class_loader_idx_;
-    } else if constexpr (jvm_v_ == kDefaultJvm) {
-      // Partially specified.
-      return kNoIdx;
-    } else {
-      // Fully specified (derived).
-      return jvm_v_.template IdxOfClassLoader<class_loader_v>();
-    }
-  }
+  static constexpr std::size_t kRank = Rankifier::Rank(Val());
 
-  static constexpr auto& MinimalSpanningClass() {
-    if constexpr (MinimalClassIdx() == kNoIdx) {
-      // If idx uncomputable, use provided.
-      return class_v_;
+  static constexpr const char* Name() {
+    if constexpr (kIdType == IdType::CLASS) {
+      return Class().name_;
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
+      return Val().name_;
+    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
+      return Id<JniT, IdType::STATIC_OVERLOAD_SET, idx, secondary_idx>::Name();
+    } else if constexpr (kIdType == IdType::STATIC_FIELD) {
+      return std::get<idx>(Class().static_.fields_).name_;
+    } else if constexpr (kIdType == IdType::OVERLOAD_SET && idx == kNoIdx) {
+      return "<init>";
+    } else if constexpr (kIdType == IdType::OVERLOAD_SET) {
+      return Val().name_;
+    } else if constexpr (kIdType == IdType::OVERLOAD) {
+      return Id<JniT, IdType::OVERLOAD_SET, idx, secondary_idx>::Name();
+    } else if constexpr (kIdType == IdType::FIELD) {
+      return std::get<idx>(Class().fields_).name_;
     } else {
-      return kNoClassSpecified;
+      return "NO_NAME";
     }
   }
+  static constexpr std::string_view kName = Name();
+  static constexpr std::string_view kNameUsingDots =
+      metaprogramming::Replace_v<kName, '/', '.'>;
 
-  static constexpr auto& MinimalSpanningClassLoader() {
-    if constexpr (MinimalClassLoaderIdx() == kNoIdx) {
-      // If idx uncomputable, use provided.
-      return class_loader_v_;
+  static constexpr std::size_t NumParams() {
+    if constexpr (kIdType == IdType::OVERLOAD ||
+                  kIdType == IdType::STATIC_OVERLOAD) {
+      return std::tuple_size_v<decltype(Val().params_.values_)>;
+    } else if constexpr (kIdType == IdType::OVERLOAD_SET ||
+                         kIdType == IdType::STATIC_OVERLOAD_SET) {
+      if constexpr (idx == kNoIdx) {
+        // Constructor.
+        return std::tuple_size_v<std::decay_t<decltype(Val())>>;
+      } else {
+        return std::tuple_size_v<std::decay_t<decltype(Val().invocations_)>>;
+      }
     } else {
-      return kNoClassLoaderSpecified;
+      // Other types don't have meaningful use of this.
+      return 1;
     }
   }
 
-  using MinimallySpanningType =
-      JniT<SpanType_, MinimalSpanningClass(), MinimalSpanningClassLoader(),
-           jvm_v_, kRank, MinimalClassIdx(), MinimalClassLoaderIdx()>;
+  static constexpr std::size_t kNumParams = NumParams();
 };
 
-template <typename T1, typename T2>
-struct JniTEqual {
-  static constexpr bool val = false;
-};
+}  // namespace jni
 
-template <
-    typename SpanType1, const auto& class_v_1, const auto& class_loader_v_1,
-    const auto& jvm_v_1, std::size_t kRank_1, std::size_t class_idx_1,
-    std::size_t class_loader_idx_1,
+#include <tuple>
 
-    typename SpanType2, const auto& class_v_2, const auto& class_loader_v_2,
-    const auto& jvm_v_2, std::size_t kRank_2, std::size_t class_idx_2,
-    std::size_t class_loader_idx_2>
-struct JniTEqual<JniT<SpanType1, class_v_1, class_loader_v_1, jvm_v_1, kRank_1,
-                      class_idx_1, class_loader_idx_1>,
-                 JniT<SpanType2, class_v_2, class_loader_v_2, jvm_v_2, kRank_2,
-                      class_idx_2, class_loader_idx_2>> {
-  static constexpr bool val =
-      std::is_same_v<SpanType1, SpanType2> &&
-      metaprogramming::ValsEqual_cr_v<class_v_1, class_v_2> &&
-      metaprogramming::ValsEqual_cr_v<class_loader_v_1, class_loader_v_2> &&
-      metaprogramming::ValsEqual_cr_v<jvm_v_1, jvm_v_2> && kRank_1 == kRank_2 &&
-      class_idx_1 == class_idx_2 && class_loader_idx_1 == class_loader_idx_2;
+namespace jni {
+
+// Provides the universe of keys, including user defined types if any.
+// Users define custom types by partially specialising UserDefined (see test).
+template <typename... Defaults>
+struct Corpus {
+  template <typename T, bool = ::jni::metaprogramming::Detect_v<
+                            UserDefined, JniUserDefinedCorpusTag>>
+  struct Helper {
+    using type = ::jni::metaprogramming::ConcatenateTup_t<
+        ::jni::metaprogramming::Detect_t<UserDefined, JniUserDefinedCorpusTag>,
+        std::tuple<Defaults...>>;
+  };
+
+  template <typename T>
+  struct Helper<T, false> {
+    using type = std::tuple<Defaults...>;
+  };
+
+  template <typename T>
+  using type = typename Helper<T>::type;
 };
 
-template <typename T1, typename T2>
-constexpr bool JniTEqual_v = JniTEqual<T1, T2>::val;
+template <typename T, typename... Defaults>
+using Corpus_t = typename Corpus<Defaults...>::template type<T>;
 
 }  // namespace jni
 
-#include <iterator>
+#include <mutex>
+#include <atomic>
+#include <functional>
 
-namespace jni {
+namespace jni::metaprogramming {
 
-// Primitive Rank 1 Arrays.
-template <typename SpanType, std::size_t kRank, typename Enable = void>
-class ArrayView {
+// This class is intended to mimic a function local static except that it
+// supports being reset. The object is constructed with a lambda and all
+// subsequent loads will be thread safe, invoking the lambda once (and only
+// once) if the currently stored value is T{0}.
+//
+// This class is thread-safe.  Loads will be cheap (after a potentially
+// expensive initial init), stores are expensive.
+template<typename T_>
+class DoubleLockedValue {
  public:
-  struct Iterator {
-    using iterator_category = std::random_access_iterator_tag;
-    using difference_type = std::size_t;
-    using value_type = SpanType;
-    using pointer = SpanType*;
-    using reference = SpanType&;
+  template <typename Lambda>
+  inline T_ LoadAndMaybeInit(Lambda lambda) {
+    // Typical case, value already initialised, perform cheap load and return.
+    T_ return_value = value_.load(std::memory_order_acquire);
 
-    Iterator(SpanType* ptr, std::size_t size, std::size_t idx)
-        : size_(size), ptr_(ptr), idx_(idx) {}
+    if(return_value != T_{0}) {
+      return return_value;
+    }
 
-    Iterator& operator++() {
-      idx_++;
-      return *this;
+    // Value was nil (uninitialised), perform heavy-weight lock.
+    std::lock_guard<std::mutex> lock_guard {lock_};
+
+    // Check another thread didn't race to lock before.
+    return_value = value_.load(std::memory_order_acquire);
+    if(return_value != T_{}) {
+      return return_value;
     }
 
-    Iterator operator++(int) {
-      Iterator tmp = *this;
-      ++(*this);
-      return tmp;
+    // Perform the potentially expensive initialisation and return.
+    return_value = lambda();
+    value_.store(return_value, std::memory_order_release);
+    return return_value;
+  }
+
+  // Sets the value to {0}.
+  inline void Reset() {
+    std::lock_guard<std::mutex> lock_guard {lock_};
+    value_.store(0, std::memory_order_release);
+  }
+
+  // Sets the value to {0} and iff the value was not {0} prior to being torn
+  // down, the teardown lambda will be invoked with this value.
+  template <typename TeardownLambda>
+  inline void Reset(TeardownLambda lambda) {
+    std::lock_guard<std::mutex> lock_guard {lock_};
+    auto val = value_.load();
+    if(val != 0) {
+      lambda(val);
+      value_.store(0, std::memory_order_release);
     }
+  }
 
-    SpanType& operator*() const { return ptr_[idx_]; }
-    const SpanType* operator->() const { return ptr_[idx_]; }
+ private:
+  std::atomic<T_> value_ = {0};
+  std::mutex lock_;
+};
 
-    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
-      return (lhs.ptr_ == rhs.ptr_) && (lhs.size_ == rhs.size_) &&
-             (lhs.idx_ == rhs.idx_);
-    };
+}  // namespace jni::metaprogramming
 
-    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
-      return !(lhs == rhs);
-    };
 
-    friend std::size_t operator-(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.idx_ - rhs.idx_;
-    };
+namespace jni {
 
-   private:
-    const std::size_t size_;
-    SpanType* const ptr_;
-    std::size_t idx_;
-  };
+template <>
+struct LifecycleHelper<jstring, LifecycleType::LOCAL>
+    : public LifecycleLocalBase<jstring> {
+  static inline jstring Construct(const char* chars) {
+    return jni::JniEnv::GetEnv()->NewStringUTF(chars);
+  }
+};
 
-  ArrayView(ArrayView&&) = delete;
-  ArrayView(const ArrayView&) = delete;
+template <>
+struct LifecycleHelper<jstring, LifecycleType::GLOBAL>
+    : public LifecycleGlobalBase<jstring> {
+  template <typename... CtorArgs>
+  static inline jstring Construct(const char* chars) {
+    using Local = LifecycleHelper<jstring, LifecycleType::LOCAL>;
 
-  ArrayView(jarray array, bool copy_on_completion, std::size_t size)
-      : array_(array),
-        get_array_elements_result_(
-            JniArrayHelper<SpanType, kRank>::GetArrayElements(array)),
-        copy_on_completion_(copy_on_completion),
-        size_(size) {}
+    jstring local_string = Local::Construct(chars);
+    jstring global_string = Promote(local_string);
+    Local::Delete(local_string);
 
-  ~ArrayView() {
-    JniArrayHelper<SpanType, kRank>::ReleaseArrayElements(
-        array_, get_array_elements_result_.ptr_, copy_on_completion_);
+    return global_string;
   }
+};
 
-  // Arrays of rank > 1 are object arrays which are not contiguous.
-  std::enable_if_t<kRank == 1, SpanType*> ptr() {
-    return get_array_elements_result_.ptr_;
+}  // namespace jni
+
+#include <utility>
+
+namespace jni {
+
+template <typename ReturnType, std::size_t kRank, bool kStatic>
+class InvokeHelper {};
+
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0 type: void
+//    void is special, but for symmetry it uses rank 0 with primitives.
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct InvokeHelper<void, 0, false> {
+  template <typename... Ts>
+  static void Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
+    jni::JniEnv::GetEnv()->CallVoidMethod(object, method_id,
+                                          std::forward<Ts>(ts)...);
   }
+};
 
-  Iterator begin() { return Iterator{ptr(), size_, 0}; }
-  Iterator end() { return Iterator{ptr(), size_, size_}; }
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0 types, i.e. the primitive type itself (e.g. int).
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct InvokeHelper<jboolean, 0, false> {
+  template <typename... Ts>
+  static jboolean Invoke(jobject object, jclass, jmethodID method_id,
+                         Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallBooleanMethod(object, method_id,
+                                                    std::forward<Ts>(ts)...);
+  }
+};
 
- protected:
-  const jarray array_;
-  const GetArrayElementsResult<SpanType> get_array_elements_result_;
-  const bool copy_on_completion_;
-  const std::size_t size_;
+template <>
+struct InvokeHelper<jint, 0, false> {
+  template <typename... Ts>
+  static jint Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallIntMethod(object, method_id,
+                                                std::forward<Ts>(ts)...);
+  }
 };
 
-// Object arrays, or arrays with rank > 1 (which are object arrays), or strings.
-template <typename SpanType, std::size_t kRank>
-class ArrayView<
-    SpanType, kRank,
-    std::enable_if_t<(kRank > 1) || std::is_same_v<SpanType, jobject> ||
-                     std::is_same_v<SpanType, jstring>>> {
- public:
-  // Metafunction that returns the type after a single dereference.
-  template <std::size_t>
-  struct PinHelper {
-    using type = jobjectArray;
-  };
-  template <>
-  struct PinHelper<2> {
-    using type = RegularToArrayTypeMap_t<SpanType>;
-  };
-  template <>
-  struct PinHelper<1> {
-    using type = jobject;
-  };
-
-  using PinHelper_t = typename PinHelper<kRank>::type;
+template <>
+struct InvokeHelper<jlong, 0, false> {
+  template <typename... Ts>
+  static jlong Invoke(jobject object, jclass, jmethodID method_id, Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallLongMethod(object, method_id,
+                                                 std::forward<Ts>(ts)...);
+  }
+};
 
-  struct Iterator {
-    using iterator_category = std::random_access_iterator_tag;
-    using difference_type = std::size_t;
-    using value_type = PinHelper_t;
-    using pointer = PinHelper_t*;
-    using reference = PinHelper_t&;
+template <>
+struct InvokeHelper<jfloat, 0, false> {
+  template <typename... Ts>
+  static jfloat Invoke(jobject object, jclass, jmethodID method_id,
+                       Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallFloatMethod(object, method_id,
+                                                  std::forward<Ts>(ts)...);
+  }
+};
 
-    Iterator(jobjectArray arr, std::size_t size, std::size_t idx)
-        : arr_(arr), size_(size), idx_(idx) {}
+template <>
+struct InvokeHelper<jdouble, 0, false> {
+  template <typename... Ts>
+  static jdouble Invoke(jobject object, jclass, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallDoubleMethod(object, method_id,
+                                                   std::forward<Ts>(ts)...);
+  }
+};
 
-    Iterator& operator++() {
-      idx_++;
-      return *this;
-    }
+template <>
+struct InvokeHelper<jobject, 0, false> {
+  // This always returns a local reference which should be embedded in type
+  // information wherever this is used.
+  template <typename... Ts>
+  static jobject Invoke(jobject object, jclass, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallObjectMethod(object, method_id,
+                                                   std::forward<Ts>(ts)...);
+  }
+};
 
-    Iterator operator++(int) {
-      Iterator tmp = *this;
-      ++(*this);
-      return tmp;
-    }
+template <>
+struct InvokeHelper<jstring, 0, false> {
+  template <typename... Ts>
+  static jobject Invoke(jobject object, jclass, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallObjectMethod(object, method_id,
+                                                   std::forward<Ts>(ts)...);
+  }
+};
 
-    PinHelper_t operator*() const {
-      if constexpr (kRank >= 2) {
-        return static_cast<PinHelper_t>(
-            JniArrayHelper<jobject, kRank>::GetArrayElement(arr_, idx_));
-      } else {
-        return JniArrayHelper<SpanType, kRank>::GetArrayElement(arr_, idx_);
-      }
-    }
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1 types, i.e. single dimension arrays (e.g. int[]).
+////////////////////////////////////////////////////////////////////////////////
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, false> {
+  template <typename... Ts>
+  static jbooleanArray Invoke(jobject object, jclass, jmethodID method_id,
+                              Ts&&... ts) {
+    return static_cast<jbooleanArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
-      return (lhs.arr_ == rhs.arr_) && (lhs.size_ == rhs.size_) &&
-             (lhs.idx_ == rhs.idx_);
-    };
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, false> {
+  template <typename... Ts>
+  static jbyteArray Invoke(jobject object, jclass, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jbyteArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
-      return !(lhs == rhs);
-    };
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, false> {
+  template <typename... Ts>
+  static jcharArray Invoke(jobject object, jclass, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jcharArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-    friend std::size_t operator-(const Iterator& lhs, const Iterator& rhs) {
-      return lhs.idx_ - rhs.idx_;
-    };
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, false> {
+  template <typename... Ts>
+  static jshortArray Invoke(jobject object, jclass, jmethodID method_id,
+                            Ts&&... ts) {
+    return static_cast<jshortArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-   private:
-    jobjectArray const arr_;
-    const std::size_t size_;
-    std::size_t idx_;
-  };
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, false> {
+  template <typename... Ts>
+  static jintArray Invoke(jobject object, jclass, jmethodID method_id,
+                          Ts&&... ts) {
+    return static_cast<jintArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-  ArrayView(ArrayView&&) = delete;
-  ArrayView(const ArrayView&) = delete;
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, false> {
+  template <typename... Ts>
+  static jlongArray Invoke(jobject object, jclass, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jlongArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-  ArrayView(jobjectArray array, bool, std::size_t size)
-      : array_(array), size_(size) {}
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, false> {
+  template <typename... Ts>
+  static jfloatArray Invoke(jobject object, jclass, jmethodID method_id,
+                            Ts&&... ts) {
+    return static_cast<jfloatArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-  Iterator begin() { return Iterator(array_, size_, 0); }
-  Iterator end() { return Iterator(array_, size_, size_); }
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, false> {
+  template <typename... Ts>
+  static jdoubleArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jdoubleArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
- protected:
-  const jobjectArray array_;
-  const std::size_t size_;
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, false> {
+  // Arrays of arrays (which this invoke represents) return object arrays
+  // (arrays themselves are objects, ergo object arrays).
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
 };
 
-// This CTAD guide is required for materialising new ArrayViews from |Pin()|
-// calls as move and copy constructors are deleted.
-template <typename SpanType, std::size_t kRank>
-ArrayView(ArrayView<SpanType, kRank>&&) -> ArrayView<SpanType, kRank>;
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-}  // namespace jni
+////////////////////////////////////////////////////////////////////////////////
+// Rank 2+ types, i.e. multi-dimension arrays (e.g. int[][], int[][][]).
+////////////////////////////////////////////////////////////////////////////////
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-#include <tuple>
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-namespace jni::metaprogramming {
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-struct Reverse {
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, false> {
   template <typename... Ts>
-  struct Helper {
-    using type = std::tuple<>;
-  };
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, false> {
   template <typename... Ts>
-  using Helper_t = typename Helper<std::tuple<Ts...>>::type;
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-  template <typename T1, typename... Ts>
-  struct Helper<std::tuple<T1, Ts...>> {
-    using type = ConcatenateTup_t<Helper_t<Ts...>, std::tuple<T1>>;
-  };
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, false> {
   template <typename... Ts>
-  using type = Helper_t<Ts...>;
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
 };
 
-template <typename... Ts>
-using Reverse_t = typename Reverse::template type<Ts...>;
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, false> {
+  // Arrays of arrays (which this invoke represents) return object arrays
+  // (arrays themselves are objects, ergo object arrays).
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-template <typename Tup>
-using Reverse_Tup = TupleUnroller_t<Reverse, Tup>;
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, false> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject object, jclass, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(jni::JniEnv::GetEnv()->CallObjectMethod(
+        object, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-}  // namespace jni::metaprogramming
+}  // namespace jni
 
 
-#include <algorithm>
-#include <tuple>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace jni {
 
-template <typename...>
-struct NBitSequence {};
+template <typename Raw, std::size_t kRank = 0, bool kStatic = false,
+          typename Enable = void>
+struct FieldHelper {
+  static Raw GetValue(jobject object_ref, jfieldID field_ref_);
 
-template <>
-struct NBitSequence<> {
-  using Increment = NBitSequence<>;
+  static void SetValue(jobject object_ref, jfieldID field_ref_, Raw&& value);
 };
 
-// Represents a sequence of "NBits".  This can be useful for generating
-// selections of pools of objects of various sizes.
-//
-// For a sequence with N values, a tuple of size N that contains tuples whose
-// sizes match those of max_values can be selected from using TypeMask.
-//
-// In other words, a sequence of N sets of sizes K0, K1, K2...KN can represent a
-// single selection with an NBitSequence where sizeof...(values) == N and
-// sizeof...(max_values) == N where Ki == max_values[i].
-template <size_t... values, size_t... max_values, bool... overflows>
-struct NBitSequence<NBit<values, max_values, overflows>...> {
-  static constexpr size_t sequence_size_ = sizeof...(values);
-
-  using Sequence = std::tuple<NBit<values, max_values, overflows>...>;
-  using TypeMask = TypeIndexMask<values...>;
-
-  template <size_t I>
-  using GetBit = TypeOfNthTupleElement_t<I, Sequence>;
-
-  // Helper method to compare values of all NBits.
-  template <size_t... Bits>
-  static constexpr bool Same(std::index_sequence<Bits...> = {}) {
-    static_assert(sizeof...(Bits) == sizeof...(values));
-    return std::is_same_v<std::index_sequence<values...>,
-                          std::index_sequence<Bits...>>;
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0: Primitive types (e.g. int).
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct FieldHelper<jboolean, 0, false, void> {
+  static inline jboolean GetValue(const jobject object_ref,
+                                  const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetBooleanField(object_ref, field_ref_);
   }
 
-  static constexpr size_t max_representable_size_ = ((max_values + 1) * ...);
-
-  template <size_t... Bits>
-  static constexpr bool same_ = Same(std::index_sequence<Bits...>{});
-
-  // If the next bit is overflowing (i.e. it just rolled over), this current
-  // value increments. Bits only overflow for a single cycle, otherwise higher
-  // order bits flip when no rollover is happening.
-  template <size_t I>
-  struct IncrementedBit {
-    using type = std::conditional_t<IncrementedBit<I + 1>::type::overflow_bit_,
-                                    typename GetBit<I>::Increment,
-                                    typename GetBit<I>::ResetOverflow>;
-  };
-
-  template <>
-  struct IncrementedBit<sequence_size_ - 1> {
-    using type = typename GetBit<sequence_size_ - 1>::Increment;
-  };
-
-  template <typename index_sequence>
-  struct IncrementSequenceHelper {};
-
-  template <size_t... Is>
-  struct IncrementSequenceHelper<std::index_sequence<Is...>> {
-    using type = NBitSequence<typename IncrementedBit<Is>::type...>;
-  };
-
-  using Increment = typename IncrementSequenceHelper<
-      std::make_index_sequence<sequence_size_>>::type;
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jboolean&& value) {
+    jni::JniEnv::GetEnv()->SetBooleanField(object_ref, field_ref_, value);
+  }
 };
 
-}  // namespace jni::metaprogramming
-
-#include <type_traits>
-
-namespace jni {
+template <>
+struct FieldHelper<jbyte, 0, false, void> {
+  static inline jbyte GetValue(const jobject object_ref,
+                               const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetByteField(object_ref, field_ref_);
+  }
 
-template <typename JniT_, IdType kIdType_, std::size_t idx,
-          std::size_t secondary_idx, std::size_t tertiary_idx>
-struct Id;
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jbyte&& value) {
+    jni::JniEnv::GetEnv()->SetByteField(object_ref, field_ref_, value);
+  }
+};
 
-// Takes an Id and produces its signature.
-template <typename>
-struct Signature {};
+template <>
+struct FieldHelper<jchar, 0, false, void> {
+  static inline jchar GetValue(const jobject object_ref,
+                               const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetCharField(object_ref, field_ref_);
+  }
 
-template <typename JniT_, IdType kIdType_, std::size_t idx,
-          std::size_t secondary_idx, std::size_t tertiary_idx>
-struct Signature<Id<JniT_, kIdType_, idx, secondary_idx, tertiary_idx>> {
-  using IdT = Id<JniT_, kIdType_, idx, secondary_idx, tertiary_idx>;
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jchar&& value) {
+    jni::JniEnv::GetEnv()->SetCharField(object_ref, field_ref_, value);
+  }
+};
 
-  static constexpr IdType kChildIdType = kIdType_ == IdType::OVERLOAD
-                                             ? IdType::OVERLOAD_PARAM
-                                             : IdType::STATIC_OVERLOAD_PARAM;
+template <>
+struct FieldHelper<jshort, 0, false, void> {
+  static inline jshort GetValue(const jobject object_ref,
+                                const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetShortField(object_ref, field_ref_);
+  }
 
-  template <typename IdxPack>
-  struct Helper;
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jshort&& value) {
+    jni::JniEnv::GetEnv()->SetShortField(object_ref, field_ref_, value);
+  }
+};
 
-  template <std::size_t... Is>
-  struct Helper<std::index_sequence<Is...>> {
-    template <std::size_t I>
-    struct Val {
-      static constexpr std::string_view val = Signature<
-          Id<JniT_, kChildIdType, idx, secondary_idx, I>>::val;
-    };
+template <>
+struct FieldHelper<jint, 0, false, void> {
+  static inline jint GetValue(const jobject object_ref,
+                              const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetIntField(object_ref, field_ref_);
+  }
 
-    static constexpr std::string_view val =
-        metaprogramming::StringConcatenate_v<Val<Is>::val...>;
-  };
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jint&& value) {
+    jni::JniEnv::GetEnv()->SetIntField(object_ref, field_ref_, value);
+  }
+};
 
-  struct ReturnHelper {
-    static constexpr std::string_view val = Signature<
-        Id<JniT_, kChildIdType, idx, secondary_idx, kNoIdx>>::val;
-  };
+template <>
+struct FieldHelper<jlong, 0, false, void> {
+  static inline jlong GetValue(const jobject object_ref,
+                               const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetLongField(object_ref, field_ref_);
+  }
 
-  // For methods and ctors generates the signature, e.g. "(II)LClass1;".
-  // For parameters, emits just a type name.
-  static constexpr std::string_view Val() {
-    if constexpr (kIdType_ == IdType::FIELD ||
-                  kIdType_ == IdType::STATIC_FIELD) {
-      return SelectorStaticInfo<IdT>::TypeName();
-    } else if constexpr (kIdType_ == IdType::OVERLOAD_SET) {
-      return "NOT_IMPLEMENTED";
-    } else if constexpr (kIdType_ == IdType::OVERLOAD ||
-                         kIdType_ == IdType::STATIC_OVERLOAD) {
-      using Idxs = std::make_index_sequence<IdT::NumParams()>;
-      if constexpr (IdT::kIsConstructor) {
-        return metaprogramming::StringConcatenate_v<
-            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
-            metaprogramming::Constants::right_parenthesis,
-            metaprogramming::Constants::V>;
-      } else {
-        return metaprogramming::StringConcatenate_v<
-            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
-            metaprogramming::Constants::right_parenthesis, ReturnHelper::val>;
-      }
-    } else if constexpr (kIdType_ == IdType::OVERLOAD_PARAM ||
-                         kIdType_ == IdType::STATIC_OVERLOAD_PARAM) {
-      return SelectorStaticInfo<IdT>::TypeName();
-    }
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jlong&& value) {
+    jni::JniEnv::GetEnv()->SetLongField(object_ref, field_ref_, value);
+  }
+};
 
-    return "NOT_IMPLEMENTED";
+template <>
+struct FieldHelper<jfloat, 0, false, void> {
+  static inline jfloat GetValue(const jobject object_ref,
+                                const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetFloatField(object_ref, field_ref_);
   }
 
-  static constexpr std::string_view val{Val()};
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jfloat&& value) {
+    jni::JniEnv::GetEnv()->SetFloatField(object_ref, field_ref_, value);
+  }
 };
 
-template <typename T>
-static constexpr auto Signature_v = Signature<T>::val;
+template <>
+struct FieldHelper<jdouble, 0, false, void> {
+  static inline jdouble GetValue(const jobject object_ref,
+                                 const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetDoubleField(object_ref, field_ref_);
+  }
 
-}  // namespace jni
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jdouble&& value) {
+    jni::JniEnv::GetEnv()->SetDoubleField(object_ref, field_ref_, value);
+  }
+};
 
-namespace jni {
+template <>
+struct FieldHelper<jobject, 0, false, void> {
+  static inline jobject GetValue(const jobject object_ref,
+                                 const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_);
+  }
 
-// Provide this base tag to UserDefined to enable custom types.
-struct JniUserDefinedCorpusTag {};
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jobject&& new_value) {
+    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, new_value);
+  }
+};
 
-// Provide a partial specialization to this class to provide custom types.
-template <typename T>
-struct UserDefined;
+template <>
+struct FieldHelper<jstring, 0, false, void> {
+  static inline jstring GetValue(const jobject object_ref,
+                                 const jfieldID field_ref_) {
+    return reinterpret_cast<jstring>(
+        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
+  }
 
-}  // namespace jni
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jstring&& new_value) {
+    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, new_value);
+  }
+};
 
-#include <atomic>
-#include <mutex>  // NOLINT
-#include <vector>
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1: Single dimension arrays (e.g. int[]).
+////////////////////////////////////////////////////////////////////////////////
+template <typename ArrayType>
+struct BaseFieldArrayHelper {
+  static inline ArrayType GetValue(const jobject object_ref,
+                                   const jfieldID field_ref_) {
+    return static_cast<ArrayType>(
+        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
+  }
 
-namespace jni {
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, ArrayType&& value) {
+    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
+  }
+};
 
-// See JvmRef::~JvmRef.
-static std::vector<metaprogramming::DoubleLockedValue<jclass>*>&
-GetDefaultLoadedClassList() {
-  static auto* ret_val =
-      new std::vector<metaprogramming::DoubleLockedValue<jclass>*>{};
-  return *ret_val;
-}
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, false, void>
+    : BaseFieldArrayHelper<jbooleanArray> {};
 
-static inline jclass LoadClassFromObject(const char* name, jobject object_ref);
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, false, void>
+    : BaseFieldArrayHelper<jbyteArray> {};
 
-// Represents a a jclass instance for a specific class. 4 flavours exist:
-//   1) Default JVM, default class loader.
-//   2) Non-default JVM, default class loader.
-//   3) Default JVM, non-default class loader.
-//   4) Non-default JVM, non default class loader (i.e. fully specified).
-//
-// Use |ClassRef_t| to provide |JniT| in its minimal form.
-template <typename JniT>
-class ClassRef {
- public:
-  static_assert(std::is_same_v<JniT, typename JniT::MinimallySpanningType>,
-                "JniT must be in its minimal form for best caching.");
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, false, void>
+    : BaseFieldArrayHelper<jcharArray> {};
 
-  template <typename Lambda>
-  static void PrimeJClassFromClassLoader(Lambda lambda) {
-    class_ref_.LoadAndMaybeInit(lambda);
-  }
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, false, void>
+    : BaseFieldArrayHelper<jshortArray> {};
 
-  static jclass GetAndMaybeLoadClassRef(
-      jobject optional_object_to_build_loader_from) {
-    // For the default classloader, storage in function local static.
-    if constexpr (JniT::GetClassLoader() == kDefaultClassLoader) {
-      static metaprogramming::DoubleLockedValue<jclass> return_value;
-      return return_value.LoadAndMaybeInit([]() {
-        GetDefaultLoadedClassList().push_back(&return_value);
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jint>, kRank, false, void>
+    : BaseFieldArrayHelper<jintArray> {};
 
-        return static_cast<jclass>(
-            LifecycleHelper<jobject, LifecycleType::GLOBAL>::Promote(
-                JniHelper::FindClass(JniT::kName.data())));
-      });
-    } else {
-      // For non default classloader, storage in class member.
-      return class_ref_.LoadAndMaybeInit([=]() {
-        return LoadClassFromObject(JniT::kNameWithDots.data(),
-                                   optional_object_to_build_loader_from);
-      });
-    }
-  }
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, false, void>
+    : BaseFieldArrayHelper<jlongArray> {};
 
-  static jclass GetAlreadyLoadedClassRef() {
-    return class_ref_.LoadAndMaybeInit([]() { return jclass{0}; });
-  }
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, false, void>
+    : BaseFieldArrayHelper<jfloatArray> {};
 
-  static void MaybeReleaseClassRef() {
-    class_ref_.Reset([](jclass maybe_loaded_class) {
-      LifecycleHelper<jclass, LifecycleType::GLOBAL>::Delete(
-          maybe_loaded_class);
-    });
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, false, void>
+    : BaseFieldArrayHelper<jdoubleArray> {};
+
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1: jobjects & jstrings.
+// Rank 2+: Multi-dimension arrays (e.g. int[][], int[][][]).
+////////////////////////////////////////////////////////////////////////////////
+template <typename T, std::size_t kRank>
+struct FieldHelper<
+    T, kRank, false,
+    std::enable_if_t<(std::is_same_v<jobject, T> ||
+                      std::is_same_v<jstring, T> || (kRank > 1))>> {
+  static inline jobjectArray GetValue(const jobject object_ref,
+                                      const jfieldID field_ref_) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
   }
 
- private:
-  // A global reference to a jclass object that is returned from FindClass.
-  // The variable has static storage because ClassIDs are static to the lifetime
-  // of a JVM.  See GetAndMaybeLoadClassRef and MaybeReleaseClassRef.
-  static inline metaprogramming::DoubleLockedValue<jclass> class_ref_;
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, jobjectArray&& value) {
+    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
+  }
 };
 
-// When we get an object_ref_ as a return value from a Java method, it may be
-// an instance of a subclass of ClassRefT. In this case, if we directly used
-// the object_ref_'s class, then we might incorrectly get member information
-// for the subclass instead of the original class. However, the original class
-// should still be loadable from the subclass's class loader, so we load the
-// ClassRef explicitly by class name.
-static inline jclass LoadClassFromObject(const char* name, jobject object_ref) {
-  // We cannot refer to the wrapper MethodRefs here, so we just manually use
-  // the class loader through JNI.
+}  // namespace jni
 
-  // Gets the ClassLoader of java/lang/class (the primordial loader).
-  // Note, these aren't static methods, they're member methods to be invoked
-  // on the object's class itself.  The class may not have been loaded yet,
-  // and all you have is a jobject
-  jclass java_lang_class_jclass =
-      ClassRef<JniT<jobject, kJavaLangClass>>::GetAndMaybeLoadClassRef(nullptr);
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
 
-  jclass java_lang_class_loader_jclass =
-      ClassRef<JniT<jobject, kJavaLangClassLoader>>::GetAndMaybeLoadClassRef(
-          nullptr);
+namespace jni {
 
-  jclass class_of_object_jclass = JniHelper::GetObjectClass(object_ref);
+template <typename t1, typename t2 = void>
+struct Proxy;
 
-  jmethodID get_class_loader_jmethod = JniHelper::GetMethodID(
-      java_lang_class_jclass, "getClassLoader", "()Ljava/lang/ClassLoader;");
+// CDecls for all declarable types (these index into proxy definitions).
+using AllKeys =
+    Corpus_t<JniUserDefinedCorpusTag, void, jboolean, jbyte, jshort, jint,
+             jfloat, jlong, jchar, jdouble, jstring, jobject, jarray,
+             jobjectArray, jintArray, jbooleanArray, jbyteArray, jcharArray,
+             jshortArray, jdoubleArray, jfloatArray, jlongArray>;
 
-  jobject object_ref_class_loader_jobject =
-      InvokeHelper<jobject, 1, false>::Invoke(class_of_object_jclass, nullptr,
-                                              get_class_loader_jmethod);
+template <typename TUndecayed>
+struct ProxyHelper {
+  using T = std::decay_t<TUndecayed>;
 
-  jmethodID load_class_jmethod =
-      JniHelper::GetMethodID(java_lang_class_loader_jclass, "loadClass",
-                             "(Ljava/lang/String;)Ljava/lang/Class;");
+  // Metafunction that builds a list of a passable type to all it's possible
+  // passable types, which may not be the same.  E.g. jint => jint, but
+  // jstring => jstring, const char*, std::string_view, std::string, etc.
+  struct IndexToKey {
+    // Proxies can be indexed by their |AsArg|s or their |AsDecl|.
+    template <typename CDecl>
+    using type = metaprogramming::CartesianProduct_t<
+        std::tuple<CDecl>,
+        metaprogramming::UniqueSet_Tup<metaprogramming::ConcatenateTup_t<
+            typename Proxy<CDecl>::AsArg, typename Proxy<CDecl>::AsDecl>>>;
+  };
 
-  jstring name_string =
-      LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(name);
-  jobject local_jclass_of_correct_loader =
-      InvokeHelper<jobject, 1, false>::Invoke(object_ref_class_loader_jobject,
-                                              nullptr, load_class_jmethod,
-                                              name_string);
-  jobject promote_jclass_of_correct_loader =
-      LifecycleHelper<jobject, LifecycleType::GLOBAL>::Promote(
-          local_jclass_of_correct_loader);
+  // Build a list of two element tuples (in preparation to build a map).  e.g.
+  // { {jint, int}, {jstring, const char*}, {jstring, std::string}, etc. }.
+  // Note that types may map to 1 or more types, such as jstring above.
+  using IndexToKeyAsTuples = metaprogramming::Reduce_t<
+      metaprogramming::Combine,
+      metaprogramming::InvokePerTupArg_t<IndexToKey, AllKeys>>;
+
+  // Collapse this list into a set of keys and values consumable by
+  // TypeToTypeMap.
+  using IndexToKeyMap = metaprogramming::TypeToTypeMapFromKeyValuesTup_t<
+      metaprogramming::Flatten_t<IndexToKeyAsTuples>>;
+
+  // When flipped, a type passed can be reverse indexed to select the same
+  // Proxy partial specialisation.
+  using KeyToIndex = metaprogramming::TypeToTypeMap_Invert<IndexToKeyMap>;
 
-  LifecycleHelper<jobject, LifecycleType::LOCAL>::Delete(
-      object_ref_class_loader_jobject);
+  using Index =
+      metaprogramming::TypeToTypeMapQueryWithComparator_t<KeyToIndex,
+                                                          IsConvertibleKey<T>>;
 
-  return static_cast<jclass>(promote_jclass_of_correct_loader);
-}
+  using Proxy_t = Proxy<Index>;
 
-template <typename JniT>
-using ClassRef_t = ClassRef<typename JniT::MinimallySpanningType>;
+  using CDecl = typename Proxy_t::CDecl;
 
-}  // namespace jni
+  template <typename Id>
+  using AsReturn_t = typename Proxy_t::template AsReturn<Id>;
 
+  template <typename ParamSelection>
+  using AsArg_t = typename Proxy_t::AsArg;
 
-namespace jni {
+  using AsDecl_t = typename Proxy_t::AsDecl;
+};
 
-struct ArrayRefPrimitiveBaseTag {};
+// Default Proxy, all types and values are pure passthrough.
+template <typename Key_>
+struct ProxyBase {
+  using Key = Key_;
 
-// Tag for non object array ref like tags (e.g. jintArray but not jobjectArray).
-template <typename JniT>
-struct ArrayRefPrimitiveTag : ArrayRefPrimitiveBaseTag {};
+  using CDecl = Key_;
 
-// |SpanType| is primitive types like jint, jfloat, etc.
-template <typename JniT, typename Enable = void>
-class ArrayRef : public RefBase<JniT>,
-                 ArrayRefPrimitiveTag<typename JniT::SpanType> {
- public:
-  using SpanType = typename JniT::SpanType;
-  using Base = RefBase<JniT>;
-  using Base::Base;
+  template <typename>
+  using AsReturn = Key_;
 
-  ArrayRef(std::size_t size)
-      : Base(JniArrayHelper<SpanType, JniT::kRank>::NewArray(size)) {}
+  using AsArg = std::tuple<Key_>;
+  using AsDecl = std::tuple<Key_>;
 
-  ArrayView<SpanType, JniT::kRank> Pin(bool copy_on_completion = true) {
-    return {Base::object_ref_, copy_on_completion, Length()};
+  template <typename T>
+  static auto ProxyAsArg(T&& t) {
+    return std::forward<T>(t);
   }
 
-  std::size_t Length() {
-    return JniArrayHelper<SpanType, JniT::kRank>::GetLength(Base::object_ref_);
-  }
+  template <typename InputParamSelectionT, typename T>
+  static constexpr bool kViable = IsConvertibleKey_v<Key_, T>;
 };
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class LocalObject;
+}  // namespace jni
 
-template <typename JniT>
-class ArrayRef<
-    JniT, std::enable_if_t<std::is_same_v<typename JniT::SpanType, jobject>>>
-    : public RefBase<JniT> {
- public:
-  using SpanType = jobject;
-  using Base = RefBase<JniT>;
-  using Base::Base;
+#include <type_traits>
+#include <variant>
 
-  std::size_t Length() {
-    return JniArrayHelper<jobject, JniT::kRank>::GetLength(Base::object_ref_);
+namespace jni {
+
+template <typename SpanType_, const auto& class_v_,
+          const auto& class_loader_v_ = kDefaultClassLoader,
+          const auto& jvm_v_ = kDefaultJvm, std::size_t kRank_ = 0,
+          std::size_t class_idx_ = kNoIdx,
+          std::size_t class_loader_idx_ = kNoIdx>
+struct JniT {
+  static constexpr std::size_t kRank = kRank_;
+
+  static constexpr bool MinimallySpecified() {
+    return (class_v_ == kNoClassSpecified
+                ? true
+                : (class_idx_ == kNoIdx ? true : false)) &&
+           (class_loader_v_ == kDefaultClassLoader
+                ? true
+                : (class_loader_idx_ == kNoIdx ? true : false));
   }
 
-  // Object arrays cannot be efficiently pinned like primitive types can.
-  ArrayView<jobject, JniT::kRank> Pin() {
-    return {Base::object_ref_, false, Length()};
+  static constexpr auto GetClass() {
+    if constexpr (class_idx_ != kNoIdx) {
+      return StripClassFromLoadedBy(
+          std::get<class_idx_>(GetClassLoader().supported_classes_));
+    } else {
+      return StripClassFromLoadedBy(class_v_);
+    }
   }
 
-  LocalObject<JniT::class_v, JniT::class_loader_v, JniT::jvm_v> Get(
-      std::size_t idx) {
-    return {JniArrayHelper<jobject, JniT::kRank>::GetArrayElement(
-        Base::object_ref_, idx)};
+  static constexpr auto GetClassLoader() {
+    if constexpr (class_loader_idx_ != kNoIdx) {
+      return StripClassLoaderFromLoadedBy(
+          std::get<class_loader_idx_>(jvm_v_.class_loaders_));
+    } else {
+      return StripClassLoaderFromLoadedBy(class_loader_v_);
+    }
   }
 
-  // Note: Globals are not permitted in a local array because it makes reasoning
-  // about them confusing.
-  //
-  // TODO(b/406948932): Permit lvalues of locals and globals as technically
-  // they're both viable (the scope will be extended as expected).
-  void Set(
-      std::size_t idx,
-      LocalObject<JniT::class_v, JniT::class_loader_v, JniT::jvm_v>&& val) {
-    return JniArrayHelper<jobject, JniT::kRank>::SetArrayElement(
-        Base::object_ref_, idx, val.Release());
+  static constexpr std::string_view kName{GetClass().name_};
+  static constexpr std::string_view kNameWithDots{
+      metaprogramming::Replace_v<kName, '/', '.'>};
+
+  static constexpr const auto& GetJvm() { return jvm_v_; }
+
+  static constexpr auto GetStatic() {
+    return FullArrayStripV(GetClass()).static_;
   }
-};
 
-}  // namespace jni
+  static constexpr decltype(GetClass()) class_v = GetClass();
+  static constexpr decltype(GetClassLoader()) class_loader_v = GetClassLoader();
+  static constexpr decltype(jvm_v_) jvm_v = jvm_v_;
+  static constexpr decltype(GetStatic()) static_v = GetStatic();
 
+  using SpanType = SpanType_;
+  using StorageType = typename StorageHelper<SpanType_, kRank>::type;
 
-namespace jni::metaprogramming {
+  using ClassT = std::decay_t<ArrayStrip_t<std::decay_t<decltype(GetClass())>>>;
+  using ClassLoaderT = std::decay_t<decltype(GetClassLoader())>;
+  using JvmT = std::decay_t<decltype(jvm_v)>;
+  using StaticT = std::decay_t<decltype(GetStatic())>;
 
-// Builds a stable (i.e. first unique type is preserved) set of unique types
-// from a set.
-struct UniqueSet {
-  template <typename... Ts>
-  struct Helper {
-    using type = std::tuple<>;
-  };
+  static constexpr ClassT stripped_class_v{FullArrayStripV(GetClass())};
 
-  template <typename... Ts>
-  using Helper_t = typename Helper<Ts...>::type;
+  ////////////////////////////////////////////////////////////////////////////
+  // Minimal Spanning type (allows perfect cacheing for fully specified jvm).
+  ////////////////////////////////////////////////////////////////////////////
 
-  // Strips the first element from the first set if it's not unique.
-  template <typename T, typename... Ts>
-  struct Helper<T, Ts...> {
-    using type =
-        std::conditional_t<!Contains_v<T, Ts...>,
-                           ConcatenateTup_t<std::tuple<T>, Helper_t<Ts...>>,
-                           Helper_t<Ts...>>;
-  };
+  // kNoIdx for default loader, then provided idx, then calculated idx.
+  static constexpr std::size_t MinimalClassIdx() {
+    if constexpr (class_idx_ != kNoIdx) {
+      // Fully specified (already).
+      return class_idx_;
+    } else if constexpr (class_loader_v_ == kDefaultClassLoader) {
+      // Partially specified.
+      return kNoIdx;
+    } else {
+      if constexpr (class_loader_v_.template IdxOfClass<class_v>() !=
+                    kClassNotInLoaderSetIdx) {
+        return class_loader_v_.template IdxOfClass<class_v>();
+      } else {
+        return kNoIdx;
+      }
+    }
+  }
 
-  template <typename... Ts>
-  using InputSetReversed = Reverse_t<Ts...>;
+  // kNoIdx for default jvm, then provided idx, then calculated idx.
+  static constexpr std::size_t MinimalClassLoaderIdx() {
+    // Fully specified (already).
+    if constexpr (class_loader_idx_ != kNoIdx) {
+      return class_loader_idx_;
+    } else if constexpr (jvm_v_ == kDefaultJvm) {
+      // Partially specified.
+      return kNoIdx;
+    } else {
+      // Fully specified (derived).
+      return jvm_v_.template IdxOfClassLoader<class_loader_v>();
+    }
+  }
 
-  template <typename... Ts>
-  using ReverseSetStrippedOfDuplicates =
-      typename TupleToType_t<InputSetReversed<Ts...>, Helper>::type;
+  static constexpr auto& MinimalSpanningClass() {
+    if constexpr (MinimalClassIdx() == kNoIdx) {
+      // If idx uncomputable, use provided.
+      return class_v_;
+    } else {
+      return kNoClassSpecified;
+    }
+  }
 
-  template <typename... Ts>
-  using type = Reverse_Tup<ReverseSetStrippedOfDuplicates<Ts...>>;
+  static constexpr auto& MinimalSpanningClassLoader() {
+    if constexpr (MinimalClassLoaderIdx() == kNoIdx) {
+      // If idx uncomputable, use provided.
+      return class_loader_v_;
+    } else {
+      return kNoClassLoaderSpecified;
+    }
+  }
+
+  using MinimallySpanningType =
+      JniT<SpanType_, MinimalSpanningClass(), MinimalSpanningClassLoader(),
+           jvm_v_, kRank, MinimalClassIdx(), MinimalClassLoaderIdx()>;
 };
 
-template <typename... Ts>
-using UniqueSet_t = typename UniqueSet::template type<Ts...>;
+template <typename T1, typename T2>
+struct JniTEqual {
+  static constexpr bool val = false;
+};
 
-template <typename Tup>
-using UniqueSet_Tup = TupleUnroller_t<UniqueSet, Tup>;
+template <
+    typename SpanType1, const auto& class_v_1, const auto& class_loader_v_1,
+    const auto& jvm_v_1, std::size_t kRank_1, std::size_t class_idx_1,
+    std::size_t class_loader_idx_1,
 
-}  // namespace jni::metaprogramming
+    typename SpanType2, const auto& class_v_2, const auto& class_loader_v_2,
+    const auto& jvm_v_2, std::size_t kRank_2, std::size_t class_idx_2,
+    std::size_t class_loader_idx_2>
+struct JniTEqual<JniT<SpanType1, class_v_1, class_loader_v_1, jvm_v_1, kRank_1,
+                      class_idx_1, class_loader_idx_1>,
+                 JniT<SpanType2, class_v_2, class_loader_v_2, jvm_v_2, kRank_2,
+                      class_idx_2, class_loader_idx_2>> {
+  static constexpr bool val =
+      std::is_same_v<SpanType1, SpanType2> &&
+      metaprogramming::ValsEqual_cr_v<class_v_1, class_v_2> &&
+      metaprogramming::ValsEqual_cr_v<class_loader_v_1, class_loader_v_2> &&
+      metaprogramming::ValsEqual_cr_v<jvm_v_1, jvm_v_2> && kRank_1 == kRank_2 &&
+      class_idx_1 == class_idx_2 && class_loader_idx_1 == class_loader_idx_2;
+};
 
+template <typename T1, typename T2>
+constexpr bool JniTEqual_v = JniTEqual<T1, T2>::val;
 
-#include <tuple>
+}  // namespace jni
 
-namespace jni::metaprogramming {
+namespace jni {
 
-// Metafunction that takes sets of tuples and reduces them to a single tuple.
-// No element in the result set will be a tuple, any and all nested tuples will
-// be flattened.
-struct Flatten {
-  template <typename... Ts>
-  struct FlattenHelper {
-    using type = std::tuple<>;
-  };
+template <LifecycleType lifecycleType, typename JniT, typename... ViableSpans>
+struct Scoped;
 
-  template <typename... TupleContents, typename... Ts>
-  struct FlattenHelper<std::tuple<TupleContents...>, Ts...> {
-    // If the type itself is a tuple, it may itself contain nested tuples.
-    using type =
-        ConcatenateTup_t<typename FlattenHelper<TupleContents...>::type,
-                         typename FlattenHelper<Ts...>::type>;
-  };
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+class LocalObject;
 
-  template <typename NonTupleType, typename... Ts>
-  struct FlattenHelper<NonTupleType, Ts...> {
-    // The first type is for certain not a tuple or the alternate specialisation
-    // would have been chosen. The value is wrapped back into a tuple, in order
-    // to exploit ConcatenateTup_t and potentially flatten any remaining args.
-    using type = ConcatenateTup_t<std::tuple<NonTupleType>,
-                                  typename FlattenHelper<Ts...>::type>;
-  };
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+class GlobalObject;
 
-  template <typename... Ts>
-  using type = typename FlattenHelper<Ts...>::type;
-};
+template <LifecycleType lifecycleType, const auto& jvm_v_,
+          const auto& class_loader_v_>
+class ClassLoaderRef;
 
-template <typename... Ts>
-using Flatten_t = typename Flatten::template type<Ts...>;
+class ThreadGuard;
+class ThreadLocalGuardDestructor;
 
-}  // namespace jni::metaprogramming
+template <typename JniT>
+struct ValidatorProxy;
 
+}  // namespace jni
 
+#include <optional>
 #include <tuple>
-#include <type_traits>
-#include <utility>
 
 namespace jni::metaprogramming {
 
-// Metafunction that takes a list of tuples, and creates a counter where each
-// value is the size of the corresponding tuple.  This can be used to create
-// every possible permutation of the input tuples.
-struct GenerateBitSequenceFromTupSets {
-  template <typename... Tups>
-  struct Helper {
-    using ListOfTups = std::tuple<Tups...>;
+template <typename>
+struct OptionalTup {};
 
-    template <typename>
-    struct SequenceGenerator {};
+// Takes a _tuple_ of types and returns a tuple with the same types except
+// wrapped in std::optional.
+template <typename... Ts>
+struct OptionalTup<std::tuple<Ts...>> {
+  using type = std::tuple<std::optional<Ts>...>;
+};
 
-    template <size_t... Is>
-    struct SequenceGenerator<std::index_sequence<Is...>> {
-      // Generates count to max size inclusive, so -1 on the size.
-      // e.g. std::tuple<int> has only 1 viable selection but would be
-      // represented by a unary NBit (i.e NBit<0, 0, false>);
-      using type =
-          NBitSequence<NBit<0,
-                            std::tuple_size_v<TypeOfNthTupleElement_t<
-                                Is, typename Helper<Tups...>::ListOfTups>> -
-                                1,
-                            false>...>;
-    };
-  };
+template <typename... Ts>
+using OptionalTup_t = typename OptionalTup<Ts...>::type;
 
-  template <typename... Tups>
-  using type = typename Helper<Tups...>::template SequenceGenerator<
-      std::make_index_sequence<sizeof...(Tups)>>::type;
-};
+}  // namespace jni::metaprogramming
 
-struct GenerateBitSequenceFromTupSetsFunc {
-  template <typename... Tups>
-  using type = typename GenerateBitSequenceFromTupSets::template type<Tups...>;
+#include <utility>
+
+namespace jni {
+
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0: Static primitive types (e.g. int).
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct FieldHelper<jboolean, 0, true, void> {
+  static inline jboolean GetValue(const jclass clazz,
+                                  const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticBooleanField(clazz, field_ref_);
+  }
+
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jboolean&& value) {
+    jni::JniEnv::GetEnv()->SetStaticBooleanField(clazz, field_ref_, value);
+  }
 };
 
-template <typename... Tups>
-using GenerateBitSequenceFromTupSets_t =
-    typename GenerateBitSequenceFromTupSets::template type<Tups...>;
+template <>
+struct FieldHelper<jbyte, 0, true, void> {
+  static inline jbyte GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticByteField(clazz, field_ref_);
+  }
 
-struct CartesianProduct {
-  template <typename... Tups>
-  struct CartesianProductHelper {
-    using NBitSequenceForTups = GenerateBitSequenceFromTupSets_t<Tups...>;
-    using AllTupsAsList = std::tuple<Tups...>;
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jbyte&& value) {
+    return jni::JniEnv::GetEnv()->SetStaticByteField(clazz, field_ref_, value);
+  }
+};
 
-    template <typename>
-    struct SequenceGenerator {};
+template <>
+struct FieldHelper<jchar, 0, true, void> {
+  static inline jchar GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticCharField(clazz, field_ref_);
+  }
 
-    template <size_t... Is>
-    struct SequenceGenerator<std::index_sequence<Is...>> {
-      using type = std::tuple<typename Increment_t<
-          NBitSequenceForTups, Is>::TypeMask::template type<AllTupsAsList>...>;
-    };
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jchar&& value) {
+    jni::JniEnv::GetEnv()->SetStaticCharField(clazz, field_ref_, value);
+  }
+};
 
-    using type = typename SequenceGenerator<std::make_index_sequence<
-        NBitSequenceForTups::max_representable_size_>>::type;
-  };
+template <>
+struct FieldHelper<jshort, 0, true, void> {
+  static inline jshort GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticShortField(clazz, field_ref_);
+  }
 
-  template <>
-  struct CartesianProductHelper<> {
-    using type = std::tuple<>;
-  };
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jshort&& value) {
+    jni::JniEnv::GetEnv()->SetStaticShortField(clazz, field_ref_, value);
+  }
+};
 
-  template <typename... Tups>
-  using type = typename CartesianProductHelper<Tups...>::type;
+template <>
+struct FieldHelper<jint, 0, true, void> {
+  static inline jint GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticIntField(clazz, field_ref_);
+  }
+
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jint&& value) {
+    jni::JniEnv::GetEnv()->SetStaticIntField(clazz, field_ref_, value);
+  }
 };
 
-template <typename... Tups>
-using CartesianProduct_t = typename CartesianProduct::template type<Tups...>;
+template <>
+struct FieldHelper<jlong, 0, true, void> {
+  static inline jlong GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticLongField(clazz, field_ref_);
+  }
 
-}  // namespace jni::metaprogramming
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jlong&& value) {
+    jni::JniEnv::GetEnv()->SetStaticLongField(clazz, field_ref_, value);
+  }
+};
 
-#include <cstddef>
-#include <type_traits>
+template <>
+struct FieldHelper<jfloat, 0, true, void> {
+  static inline jfloat GetValue(const jclass clazz, const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticFloatField(clazz, field_ref_);
+  }
 
-namespace jni {
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jfloat&& value) {
+    jni::JniEnv::GetEnv()->SetStaticFloatField(clazz, field_ref_, value);
+  }
+};
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class LocalObject;
+template <>
+struct FieldHelper<jdouble, 0, true, void> {
+  static inline jdouble GetValue(const jclass clazz,
+                                 const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticDoubleField(clazz, field_ref_);
+  }
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class GlobalObject;
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jdouble&& value) {
+    jni::JniEnv::GetEnv()->SetStaticDoubleField(clazz, field_ref_, value);
+  }
+};
 
-// Represents a an array object (e.g. int[], float[][], Object[], etc).
-// Currently GlobalArrays do not exist, as reasoning about the lifecycles of the
-// underlying objects is non-trivial, e.g. a GlobalArray taking a local object
-// would result in a possibly unexpected extension of lifetime.
-template <typename SpanType, std::size_t kRank_ = 1,
-          const auto& class_v_ = kNoClassSpecified,
-          const auto& class_loader_v_ = kDefaultClassLoader,
-          const auto& jvm_v_ = kDefaultJvm>
-class LocalArray
-    : public ArrayRef<
-          JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>> {
- public:
-  using JniT_ = JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>;
-  using ObjectClassRefT = ClassRef_t<JniT_>;
+template <>
+struct FieldHelper<jobject, 0, true, void> {
+  static inline jobject GetValue(const jclass clazz,
+                                 const jfieldID field_ref_) {
+    return jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_);
+  }
 
-  using Base =
-      ArrayRef<JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>>;
-  using Base::Base;
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jobject&& new_value) {
+    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, new_value);
+  }
+};
 
-  LocalArray(LocalArray<SpanType, kRank_>&& rhs) : Base(rhs.Release()) {}
+template <>
+struct FieldHelper<jstring, 0, true, void> {
+  static inline jstring GetValue(const jclass clazz,
+                                 const jfieldID field_ref_) {
+    return reinterpret_cast<jstring>(
+        jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_));
+  }
 
-  template <std::size_t kRank, const auto& class_v, const auto& class_loader_v,
-            const auto& jvm_v>
-  LocalArray(LocalArray<jobject, kRank, class_v, class_loader_v, jvm_v>&& rhs)
-      : Base(rhs.Release()) {
-    static_assert(kRank == kRank_ && class_v == class_v_ &&
-                  class_loader_v == class_loader_v_);
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jstring&& new_value) {
+    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, new_value);
   }
+};
 
-  // Construct from LocalObject lvalue (object is used as template).
-  //
-  // e.g.
-  //  LocalArray arr { 5, LocalObject<kClass> {args...} };
-  //  LocalArray arr { 5, GlobalObject<kClass> {args...} };
-  template <template <const auto&, const auto&, const auto&>
-            class ObjectContainer,
-            const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-  LocalArray(
-      std::size_t size,
-      const ObjectContainer<class_v, class_loader_v, jvm_v>& local_object)
-      : Base(JniArrayHelper<jobject, kRank_>::NewArray(
-            size,
-            ObjectClassRefT::GetAndMaybeLoadClassRef(
-                static_cast<jobject>(local_object)),
-            static_cast<jobject>(local_object))) {}
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1: Static single dimension arrays (e.g. int[]).
+////////////////////////////////////////////////////////////////////////////////
+template <typename ArrayType>
+struct StaticBaseFieldArrayHelper {
+  static inline ArrayType GetValue(const jobject object_ref,
+                                   const jfieldID field_ref_) {
+    return static_cast<ArrayType>(
+        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
+  }
 
-  ~LocalArray() {
-    if (Base::object_ref_) {
-      LifecycleHelper<jobject, LifecycleType::LOCAL>::Delete(Base::object_ref_);
-    }
+  static inline void SetValue(const jobject object_ref,
+                              const jfieldID field_ref_, ArrayType&& value) {
+    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
   }
 };
 
-template <template <const auto&, const auto&, const auto&>
-          class ObjectContainer,
-          const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-LocalArray(std::size_t,
-           const ObjectContainer<class_v_, class_loader_v_, jvm_v_>&)
-    -> LocalArray<jobject, class_v_, class_loader_v_, jvm_v_>;
-
-template <typename SpanType>
-LocalArray(std::size_t, SpanType)
-    -> LocalArray<SpanType, 1, kNoClassSpecified, kDefaultClassLoader,
-                  kDefaultJvm>;
-
-template <const auto& kArrayVal>
-struct LocalArrayBuildFromArray_Helper {};
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jbooleanArray> {};
 
-template <typename TUndecayed>
-struct ProxyHelper;
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jbyteArray> {};
 
-}  // namespace jni
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jcharArray> {};
 
-#include <cstddef>
-#include <limits>
-#include <string_view>
-#include <utility>
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jshortArray> {};
 
-namespace jni {
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jint>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jintArray> {};
 
-template <typename JniT_, IdType kIdType_, std::size_t idx = kNoIdx,
-          std::size_t secondary_idx = kNoIdx, std::size_t tertiary_idx = kNoIdx>
-struct Id {
-  using JniT = JniT_;
-  static constexpr IdType kIdType = kIdType_;
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jlongArray> {};
 
-  static constexpr auto Class() { return JniT::GetClass(); }
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jfloatArray> {};
 
-  static constexpr std::size_t kIdx = idx;
-  static constexpr std::size_t kSecondaryIdx = secondary_idx;
-  static constexpr std::size_t kTertiaryIdx = tertiary_idx;
+template <std::size_t kRank>
+struct FieldHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, true, void>
+    : StaticBaseFieldArrayHelper<jdoubleArray> {};
 
-  static constexpr bool kIsConstructor =
-      (kIdType == IdType::OVERLOAD || kIdType == IdType::OVERLOAD_PARAM ||
-       kIdType == IdType::OVERLOAD_SET) &&
-      (kIdx == kNoIdx);
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1: Static jobjects.
+// Rank 2+: Static multi-dimension arrays (e.g. int[][], int[][][]).
+////////////////////////////////////////////////////////////////////////////////
+template <typename T, std::size_t kRank>
+struct FieldHelper<
+    T, kRank, true,
+    std::enable_if_t<(std::is_same_v<jobject, T> || (kRank > 1))>> {
+  static inline jobjectArray GetValue(const jclass clazz,
+                                      const jfieldID field_ref_) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_));
+  }
 
-  static constexpr bool kIsStatic = kIdType == IdType::STATIC_OVERLOAD_SET ||
-                                    kIdType == IdType::STATIC_OVERLOAD ||
-                                    kIdType == IdType::STATIC_OVERLOAD_PARAM ||
-                                    kIdType == IdType::STATIC_FIELD;
+  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
+                              jobjectArray&& value) {
+    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, value);
+  }
+};
 
-  template <IdType new_id_type>
-  using ChangeIdType = Id<JniT, new_id_type, idx, secondary_idx, tertiary_idx>;
+}  // namespace jni
 
-  template <std::size_t kIdxToChange, std::size_t kNewValue>
-  using ChangeIdx = Id<JniT, kIdType, (kIdxToChange == 0 ? kNewValue : idx),
-                       (kIdxToChange == 1 ? kNewValue : secondary_idx),
-                       (kIdxToChange == 2 ? kNewValue : tertiary_idx)>;
+#include <cstddef>
+#include <utility>
 
-  static constexpr auto Val() {
-    if constexpr (kIdType == IdType::CLASS) {
-      return Class();
-    } else if constexpr (kIdType == IdType::STATIC_FIELD) {
-      static_assert(idx != kNoIdx);
-      return std::get<idx>(Class().static_.fields_).raw_;
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
-      // Overload (no such thing as static constructor).
-      static_assert(idx != kNoIdx);
-      return std::get<idx>(Class().static_.methods_);
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
-      // Overload (no such thing as static constructor).
-      static_assert(idx != kNoIdx);
-      return std::get<secondary_idx>(
-          std::get<idx>(Class().static_.methods_).invocations_);
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_PARAM) {
-      // Overload.
-      if constexpr (tertiary_idx == kNoIdx) {
-        // Return.
-        return std::get<secondary_idx>(
-                   std::get<idx>(Class().static_.methods_).invocations_)
-            .return_.raw_;
-      } else {
-        return std::get<tertiary_idx>(
-            std::get<secondary_idx>(
-                std::get<idx>(Class().static_.methods_).invocations_)
-                .params_.values_);
-      }
-    } else if constexpr (kIdType == IdType::OVERLOAD_SET) {
-      if constexpr (idx == kNoIdx) {
-        // Constructor.
-        return Class().constructors_;
-      } else {
-        // Overload.
-        return std::get<idx>(Class().methods_);
-      }
-    } else if constexpr (kIdType == IdType::OVERLOAD) {
-      if constexpr (idx == kNoIdx) {
-        // Constructor.
-        return std::get<secondary_idx>(Class().constructors_);
-      } else {
-        // Overload.
-        return std::get<secondary_idx>(
-            std::get<idx>(Class().methods_).invocations_);
-      }
-    } else if constexpr (kIdType == IdType::OVERLOAD_PARAM) {
-      if constexpr (idx == kNoIdx) {
-        // Constructor.
-        if constexpr (tertiary_idx == kNoIdx) {
-          // Return.
-          return Class();
-        } else {
-          // Overload return.
-          return std::get<tertiary_idx>(
-              std::get<secondary_idx>(Class().constructors_).params_.values_);
-        }
-      } else {
-        // Overload.
-        if constexpr (tertiary_idx == kNoIdx) {
-          // Return.
-          return std::get<secondary_idx>(
-                     std::get<idx>(Class().methods_).invocations_)
-              .return_.raw_;
-        } else {
-          return std::get<tertiary_idx>(
-              std::get<secondary_idx>(
-                  std::get<idx>(Class().methods_).invocations_)
-                  .params_.values_);
-        }
-      }
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
-      // Overload (no static_assert).
-      static_assert(idx != kNoIdx);
+namespace jni {
 
-      return std::get<secondary_idx>(
-          std::get<idx>(Class().static_methods_).invocations_);
-    } else if constexpr (kIdType == IdType::FIELD) {
-      static_assert(idx != kNoIdx);
-      return std::get<idx>(Class().fields_).raw_;
-    }
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0 type (aka void).
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct InvokeHelper<void, 0, true> {
+  template <typename... Ts>
+  static void Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
+    jni::JniEnv::GetEnv()->CallStaticVoidMethod(clazz, method_id,
+                                                std::forward<Ts>(ts)...);
   }
+};
 
-  // Returns root for constructor, else return's "raw_" member.
-  static constexpr auto Materialize() {
-    if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
-      return Val().return_.raw_;
-    } else if constexpr (kIdType == IdType::OVERLOAD) {
-      if constexpr (kIdx == kNoIdx) {
-        // Constructor.
-        return Class();
-      } else {
-        // Overload return value.
-        return Val().return_.raw_;
-      }
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET ||
-                         kIdType == IdType::OVERLOAD_SET) {
-      // Not implemented.
-      return Void{};
-    } else {
-      return Val();
-    }
+////////////////////////////////////////////////////////////////////////////////
+// Rank 0 types, i.e. the primitive type itself (e.g. int).
+////////////////////////////////////////////////////////////////////////////////
+template <>
+struct InvokeHelper<jboolean, 0, true> {
+  template <typename... Ts>
+  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
+                         Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticBooleanMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
   }
+};
 
-  using MaterializeT = std::decay_t<decltype(Materialize())>;
-  using RawMaterializeT = ArrayStrip_t<MaterializeT>;
-  static constexpr std::size_t kMaterializedRank =
-      Rankifier::Rank(Materialize());
-  using MaterializeCDeclT = std::decay_t<VoidIfVoid_t<decltype(Materialize())>>;
-
-  using RawValT = ArrayStrip_t<std::decay_t<decltype(Val())>>;
-  using UnstrippedRawVal = std::decay_t<decltype(Val())>;
-  using CDecl = CDecl_t<VoidIfVoid_t<MaterializeT>>;
-
-  static constexpr std::size_t kRank = Rankifier::Rank(Val());
+template <>
+struct InvokeHelper<jbyte, 0, true> {
+  template <typename... Ts>
+  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
+                         Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticByteMethod(clazz, method_id,
+                                                       std::forward<Ts>(ts)...);
+  }
+};
 
-  static constexpr const char* Name() {
-    if constexpr (kIdType == IdType::CLASS) {
-      return Class().name_;
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD_SET) {
-      return Val().name_;
-    } else if constexpr (kIdType == IdType::STATIC_OVERLOAD) {
-      return Id<JniT, IdType::STATIC_OVERLOAD_SET, idx, secondary_idx>::Name();
-    } else if constexpr (kIdType == IdType::STATIC_FIELD) {
-      return std::get<idx>(Class().static_.fields_).name_;
-    } else if constexpr (kIdType == IdType::OVERLOAD_SET && idx == kNoIdx) {
-      return "<init>";
-    } else if constexpr (kIdType == IdType::OVERLOAD_SET) {
-      return Val().name_;
-    } else if constexpr (kIdType == IdType::OVERLOAD) {
-      return Id<JniT, IdType::OVERLOAD_SET, idx, secondary_idx>::Name();
-    } else if constexpr (kIdType == IdType::FIELD) {
-      return std::get<idx>(Class().fields_).name_;
-    } else {
-      return "NO_NAME";
-    }
+template <>
+struct InvokeHelper<jchar, 0, true> {
+  template <typename... Ts>
+  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
+                         Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticCharMethod(clazz, method_id,
+                                                       std::forward<Ts>(ts)...);
   }
-  static constexpr std::string_view kName = Name();
-  static constexpr std::string_view kNameUsingDots =
-      metaprogramming::Replace_v<kName, '/', '.'>;
+};
 
-  static constexpr std::size_t NumParams() {
-    if constexpr (kIdType == IdType::OVERLOAD ||
-                  kIdType == IdType::STATIC_OVERLOAD) {
-      return std::tuple_size_v<decltype(Val().params_.values_)>;
-    } else if constexpr (kIdType == IdType::OVERLOAD_SET ||
-                         kIdType == IdType::STATIC_OVERLOAD_SET) {
-      if constexpr (idx == kNoIdx) {
-        // Constructor.
-        return std::tuple_size_v<std::decay_t<decltype(Val())>>;
-      } else {
-        return std::tuple_size_v<std::decay_t<decltype(Val().invocations_)>>;
-      }
-    } else {
-      // Other types don't have meaningful use of this.
-      return 1;
-    }
+template <>
+struct InvokeHelper<jshort, 0, true> {
+  template <typename... Ts>
+  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
+                         Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticShortMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
   }
-
-  static constexpr std::size_t kNumParams = NumParams();
 };
 
-}  // namespace jni
+template <>
+struct InvokeHelper<jint, 0, true> {
+  template <typename... Ts>
+  static jint Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticIntMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...);
+  }
+};
 
-#include <tuple>
+template <>
+struct InvokeHelper<jlong, 0, true> {
+  template <typename... Ts>
+  static jlong Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticLongMethod(clazz, method_id,
+                                                       std::forward<Ts>(ts)...);
+  }
+};
 
-namespace jni {
+template <>
+struct InvokeHelper<jfloat, 0, true> {
+  template <typename... Ts>
+  static jfloat Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticFloatMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
+  }
+};
 
-// Provides the universe of keys, including user defined types if any.
-// Users define custom types by partially specialising UserDefined (see test).
-template <typename... Defaults>
-struct Corpus {
-  template <typename T, bool = ::jni::metaprogramming::Detect_v<
-                            UserDefined, JniUserDefinedCorpusTag>>
-  struct Helper {
-    using type = ::jni::metaprogramming::ConcatenateTup_t<
-        ::jni::metaprogramming::Detect_t<UserDefined, JniUserDefinedCorpusTag>,
-        std::tuple<Defaults...>>;
-  };
+template <>
+struct InvokeHelper<jdouble, 0, true> {
+  template <typename... Ts>
+  static jdouble Invoke(jobject, jclass clazz, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticDoubleMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
+  }
+};
 
-  template <typename T>
-  struct Helper<T, false> {
-    using type = std::tuple<Defaults...>;
-  };
+template <>
+struct InvokeHelper<jobject, 0, true> {
+  // This always returns a local reference which should be embedded in type
+  // information wherever this is used.
+  template <typename... Ts>
+  static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticObjectMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
+  }
+};
 
-  template <typename T>
-  using type = typename Helper<T>::type;
+template <>
+struct InvokeHelper<jstring, 0, true> {
+  template <typename... Ts>
+  static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
+                        Ts&&... ts) {
+    return jni::JniEnv::GetEnv()->CallStaticObjectMethod(
+        clazz, method_id, std::forward<Ts>(ts)...);
+  }
 };
 
-template <typename T, typename... Defaults>
-using Corpus_t = typename Corpus<Defaults...>::template type<T>;
+////////////////////////////////////////////////////////////////////////////////
+// Rank 1 types, i.e. single dimension arrays (e.g. int[]).
+////////////////////////////////////////////////////////////////////////////////
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, true> {
+  template <typename... Ts>
+  static jbooleanArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                              Ts&&... ts) {
+    return static_cast<jbooleanArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
+  }
+};
 
-}  // namespace jni
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, true> {
+  template <typename... Ts>
+  static jbyteArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jbyteArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
+  }
+};
 
-#include <utility>
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, true> {
+  template <typename... Ts>
+  static jcharArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jcharArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
+  }
+};
 
-namespace jni {
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, true> {
+  template <typename... Ts>
+  static jshortArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                            Ts&&... ts) {
+    return static_cast<jshortArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
+  }
+};
 
-template <typename Raw, std::size_t kRank = 0, bool kStatic = false,
-          typename Enable = void>
-struct FieldHelper {
-  static Raw GetValue(jobject object_ref, jfieldID field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, true> {
+  template <typename... Ts>
+  static jintArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                          Ts&&... ts) {
+    return static_cast<jintArray>(jni::JniEnv::GetEnv()->CallStaticObjectMethod(
+        clazz, method_id, std::forward<Ts>(ts)...));
+  }
+};
 
-  static void SetValue(jobject object_ref, jfieldID field_ref_, Raw&& value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, true> {
+  template <typename... Ts>
+  static jfloatArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                            Ts&&... ts) {
+    return static_cast<jfloatArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
+  }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0: Primitive types (e.g. int).
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct FieldHelper<jboolean, 0, false, void> {
-  static inline jboolean GetValue(const jobject object_ref,
-                                  const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetBooleanField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, true> {
+  template <typename... Ts>
+  static jdoubleArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jdoubleArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jboolean&& value) {
-    jni::JniEnv::GetEnv()->SetBooleanField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, true> {
+  template <typename... Ts>
+  static jlongArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                           Ts&&... ts) {
+    return static_cast<jlongArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jbyte, 0, false, void> {
-  static inline jbyte GetValue(const jobject object_ref,
-                               const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetByteField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, true> {
+  // Arrays of arrays (which this invoke represents) return object arrays
+  // (arrays themselves are objects, ergo object arrays).
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jbyte&& value) {
-    jni::JniEnv::GetEnv()->SetByteField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jchar, 0, false, void> {
-  static inline jchar GetValue(const jobject object_ref,
-                               const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetCharField(object_ref, field_ref_);
+////////////////////////////////////////////////////////////////////////////////
+// Rank 2+ types, i.e. multi-dimension arrays (e.g. int[][], int[][][]).
+////////////////////////////////////////////////////////////////////////////////
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jchar&& value) {
-    jni::JniEnv::GetEnv()->SetCharField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jshort, 0, false, void> {
-  static inline jshort GetValue(const jobject object_ref,
-                                const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetShortField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jshort&& value) {
-    jni::JniEnv::GetEnv()->SetShortField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jint, 0, false, void> {
-  static inline jint GetValue(const jobject object_ref,
-                              const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetIntField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jint&& value) {
-    jni::JniEnv::GetEnv()->SetIntField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jlong, 0, false, void> {
-  static inline jlong GetValue(const jobject object_ref,
-                               const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetLongField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jlong&& value) {
-    jni::JniEnv::GetEnv()->SetLongField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jfloat, 0, false, void> {
-  static inline jfloat GetValue(const jobject object_ref,
-                                const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetFloatField(object_ref, field_ref_);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, true> {
+  // Arrays of arrays (which this invoke represents) return object arrays
+  // (arrays themselves are objects, ergo object arrays).
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
+};
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jfloat&& value) {
-    jni::JniEnv::GetEnv()->SetFloatField(object_ref, field_ref_, value);
+template <std::size_t kRank>
+struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, true> {
+  template <typename... Ts>
+  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
+                             Ts&&... ts) {
+    return static_cast<jobjectArray>(
+        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
+                                                      std::forward<Ts>(ts)...));
   }
 };
 
-template <>
-struct FieldHelper<jdouble, 0, false, void> {
-  static inline jdouble GetValue(const jobject object_ref,
-                                 const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetDoubleField(object_ref, field_ref_);
-  }
+}  // namespace jni
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jdouble&& value) {
-    jni::JniEnv::GetEnv()->SetDoubleField(object_ref, field_ref_, value);
-  }
-};
+#include <iterator>
+#include <string>
+#include <type_traits>
 
-template <>
-struct FieldHelper<jobject, 0, false, void> {
-  static inline jobject GetValue(const jobject object_ref,
-                                 const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_);
-  }
+namespace jni {
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jobject&& new_value) {
-    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, new_value);
+class LocalString;
+class GlobalString;
+
+template <typename SpanType, std::size_t kRank, const auto& class_v_,
+          const auto& class_loader_v_, const auto& jvm_v_>
+class LocalArray;
+
+template <typename JString>
+struct Proxy<JString,
+             typename std::enable_if_t<std::is_same_v<JString, jstring>>>
+    : public ProxyBase<JString> {
+  template <typename Id, std::size_t kRank>
+  struct Helper {
+    using type = LocalArray<jstring, kRank, kJavaLangString,
+                            kDefaultClassLoader, kDefaultJvm>;
+  };
+
+  template <typename Id>
+  struct Helper<Id, 0> {
+    using type = LocalString;
+  };
+
+  using AsArg = std::tuple<std::string, jstring, char*, const char*,
+                           std::string_view, RefBaseTag<jstring>>;
+
+  template <typename Id>
+  using AsReturn = typename Helper<Id, Id::kRank>::type;
+
+  template <typename OverloadSelection, typename T>
+  static constexpr bool kViable =
+      IsConvertibleKey<T>::template value<std::string> ||
+      IsConvertibleKey<T>::template value<jstring> ||
+      IsConvertibleKey<T>::template value<char*> ||
+      IsConvertibleKey<T>::template value<const char*> ||
+      IsConvertibleKey<T>::template value<std::string_view> ||
+      std::is_same_v<T, LocalString> || std::is_same_v<T, GlobalString>;
+
+  // These leak local instances of strings.  Usually, RAII mechanisms would
+  // correctly release local instances, but here we are stripping that so it can
+  // be used in a method.  This could be obviated by wrapping the calling scope
+  // in a local stack frame.
+  static jstring ProxyAsArg(jstring s) { return s; }
+
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, const char*> ||
+                                        std::is_same_v<T, std::string> ||
+                                        std::is_same_v<T, std::string_view>>>
+  static jstring ProxyAsArg(T s) {
+    if constexpr (std::is_same_v<T, const char*>) {
+      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(s);
+    } else {
+      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(
+          s.data());
+    }
   }
-};
 
-template <>
-struct FieldHelper<jstring, 0, false, void> {
-  static inline jstring GetValue(const jobject object_ref,
-                                 const jfieldID field_ref_) {
-    return reinterpret_cast<jstring>(
-        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, GlobalString> ||
+                                        std::is_same_v<T, LocalString>>>
+  static jstring ProxyAsArg(T& t) {
+    return jstring{t};
   }
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jstring&& new_value) {
-    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, new_value);
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, GlobalString> ||
+                                        std::is_same_v<T, LocalString>>>
+  static jstring ProxyAsArg(T&& t) {
+    return t.Release();
   }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1: Single dimension arrays (e.g. int[]).
-////////////////////////////////////////////////////////////////////////////////
-template <typename ArrayType>
-struct BaseFieldArrayHelper {
-  static inline ArrayType GetValue(const jobject object_ref,
-                                   const jfieldID field_ref_) {
-    return static_cast<ArrayType>(
-        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
-  }
+}  // namespace jni
+
+namespace jni {
+
+template <typename Overload>
+struct ArrayHelper;
+
+template <typename SpanType, std::size_t kRank, const auto& class_v_,
+          const auto& class_loader_v_, const auto& jvm_v_>
+class LocalArray;
+
+template <typename JArrayType>
+struct Proxy<JArrayType, typename std::enable_if_t<
+                             std::is_convertible_v<JArrayType, jarray>>>
+    : public ProxyBase<JArrayType> {
+  // Non-array primitive type (e.g. jintArray => jint).
+  using CDecl = ArrayToRegularTypeMap_t<JArrayType>;
+
+  // Primitive Array Types (e.g. if JArrayType is jintarray and T is too).
+  template <typename ParamSelection, typename T, typename Enable = void>
+  struct Helper {
+    static constexpr bool val =
+        (std::is_same_v<T, JArrayType> && ParamSelection::kRank == 1) ||
+        (std::is_same_v<T, jobjectArray> && ParamSelection::kRank >= 2);
+  };
+
+  // LocalArray.
+  template <typename ParamSelection, typename SpanType, std::size_t kRank,
+            const auto& class_v_, const auto& class_loader_v_,
+            const auto& jvm_v_>
+  struct Helper<ParamSelection, LocalArray<SpanType, kRank, class_v_,
+                                           class_loader_v_, jvm_v_>> {
+    static constexpr auto param_copy = FullArrayStripV(ParamSelection::Val());
+
+    static constexpr bool val =
+        (kRank == ParamSelection::kRank) &&
+        (std::is_same_v<SpanType, typename ParamSelection::RawValT> ||
+         (std::is_same_v<SpanType, jobjectArray> &&
+          ParamSelection::kRank >= 2) ||
+         (std::string_view{class_v_.name_} == NameOrNothing_v<param_copy>));
+  };
+
+  template <typename ParamSelection, typename T>
+  static constexpr bool kViable = Helper<ParamSelection, T>::val;
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, ArrayType&& value) {
-    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
-  }
-};
+  using AsDecl = std::tuple<ArrayTag<JArrayType>>;
+  using AsArg =
+      std::tuple<JArrayType, RefBaseTag<JArrayType>, ArrayTag<JArrayType>>;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, false, void>
-    : BaseFieldArrayHelper<jbooleanArray> {};
+  template <typename Id>
+  using AsReturn = typename ArrayHelper<Id>::AsReturn;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, false, void>
-    : BaseFieldArrayHelper<jbyteArray> {};
+  static JArrayType ProxyAsArg(JArrayType arr) { return arr; };
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, false, void>
-    : BaseFieldArrayHelper<jcharArray> {};
+  template <typename T>
+  static JArrayType ProxyAsArg(const T& t) {
+    return JArrayType{t};
+  };
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, false, void>
-    : BaseFieldArrayHelper<jshortArray> {};
+  template <typename T, typename = std::enable_if_t<
+                            std::is_base_of_v<RefBaseTag<JArrayType>, T>>>
+  static JArrayType ProxyAsArg(T&& t) {
+    return t.Release();
+  };
+};
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jint>, kRank, false, void>
-    : BaseFieldArrayHelper<jintArray> {};
+// This must be defined outside of Proxy so implicit definition doesn't occur.
+template <typename IdT>
+struct ArrayHelper {
+  template <const auto& t>
+  struct Helper {
+    static constexpr auto val = FullArrayStripV(t.raw_);
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, false, void>
-    : BaseFieldArrayHelper<jlongArray> {};
+    using StrippedCDecl = CDecl_t<std::decay_t<decltype(val)>>;
+    using ConvertedCDecl = RegularToArrayTypeMap_t<StrippedCDecl>;
+  };
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, false, void>
-    : BaseFieldArrayHelper<jfloatArray> {};
+  static constexpr auto kVal{IdT::Materialize()};
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, false, void>
-    : BaseFieldArrayHelper<jdoubleArray> {};
+  static constexpr auto LocalArrayBuildFromArray() {
+    using RawT = typename IdT::RawMaterializeT;
+    constexpr std::size_t kRank = IdT::kMaterializedRank;
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1: jobjects & jstrings.
-// Rank 2+: Multi-dimension arrays (e.g. int[][], int[][][]).
-////////////////////////////////////////////////////////////////////////////////
-template <typename T, std::size_t kRank>
-struct FieldHelper<
-    T, kRank, false,
-    std::enable_if_t<(std::is_same_v<jobject, T> ||
-                      std::is_same_v<jstring, T> || (kRank > 1))>> {
-  static inline jobjectArray GetValue(const jobject object_ref,
-                                      const jfieldID field_ref_) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
+    if constexpr (!std::is_same_v<CDecl_t<RawT>, jobject>) {
+      return LocalArray<RawT, kRank, kNoClassSpecified, kDefaultClassLoader,
+                        kDefaultJvm>{1};
+    } else {
+      return LocalArray<jobject, kRank, Helper<kVal>::val, kDefaultClassLoader,
+                        kDefaultJvm>{jobjectArray{nullptr}};
+    }
   }
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, jobjectArray&& value) {
-    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
-  }
+  using StrippedCDecl = typename Helper<kVal>::StrippedCDecl;
+  using ConvertedCDecl = typename Helper<kVal>::ConvertedCDecl;
+
+  using AsReturn = decltype(LocalArrayBuildFromArray());
 };
 
 }  // namespace jni
 
 #include <string>
 #include <string_view>
+#include <tuple>
 #include <type_traits>
-#include <utility>
 
 namespace jni {
 
-template <typename t1, typename t2 = void>
-struct Proxy;
-
-// CDecls for all declarable types (these index into proxy definitions).
-using AllKeys =
-    Corpus_t<JniUserDefinedCorpusTag, void, jboolean, jbyte, jshort, jint,
-             jfloat, jlong, jchar, jdouble, jstring, jobject, jarray,
-             jobjectArray, jintArray, jbooleanArray, jbyteArray, jcharArray,
-             jshortArray, jdoubleArray, jfloatArray, jlongArray>;
-
 template <typename TUndecayed>
-struct ProxyHelper {
-  using T = std::decay_t<TUndecayed>;
+struct ProxyHelper;
 
-  // Metafunction that builds a list of a passable type to all it's possible
-  // passable types, which may not be the same.  E.g. jint => jint, but
-  // jstring => jstring, const char*, std::string_view, std::string, etc.
-  struct IndexToKey {
-    // Proxies can be indexed by their |AsArg|s or their |AsDecl|.
-    template <typename CDecl>
-    using type = metaprogramming::CartesianProduct_t<
-        std::tuple<CDecl>,
-        metaprogramming::UniqueSet_Tup<metaprogramming::ConcatenateTup_t<
-            typename Proxy<CDecl>::AsArg, typename Proxy<CDecl>::AsDecl>>>;
-  };
+// Proxy is a metafunction that gives useful conversions from
+// types and forwards to a corresponding type that's viable as input.
+//
+// Note, given the context, different types present differently.  E.g. a |jint|
+// is always a jint, but a |jobject| is declared as a |jni::Class|, passed as a
+// |jni::RefBase&| and then converted to a |jobject| to cross the C API.
+//
+// |Proxy_t| will select the correct proxy for any of the above types.  To be
+// specific, |Proxy_t| of any type in |Arg| or |AsDecl| will return
+// the parent Proxy.
+//
+// Each proxy exports aliases for a given |CDecl|.
+//  |Index|: A uniquely identifying Key for proxy lookup.  This is usually the
+//    CDecl (e.g. jint => jint), but rich types may differ (Object =>jobject).
+//  |CDecl|: This is both the unique ID for a given proxy, as well as the
+//    distinct type (of which there is only one) that is usable when invoking a
+//    JNI call through the C API (e.g. |jint|, |jobject|).
+//  |AsArg|: All valid passable types.
+//  |AsDecl|: The type to be used in a function declaration, either as
+//   return or as a declared argument. If is templated by |class_v| and
+//   |class_loader_v| which can allow for additional decoration.
+template <typename CDecl, typename Enable>
+struct Proxy : public ProxyBase<CDecl> {};
 
-  // Build a list of two element tuples (in preparation to build a map).  e.g.
-  // { {jint, int}, {jstring, const char*}, {jstring, std::string}, etc. }.
-  // Note that types may map to 1 or more types, such as jstring above.
-  using IndexToKeyAsTuples = metaprogramming::Reduce_t<
-      metaprogramming::Combine,
-      metaprogramming::InvokePerTupArg_t<IndexToKey, AllKeys>>;
+template <typename VoidType>
+struct Proxy<VoidType,
+             typename std::enable_if_t<std::is_same_v<VoidType, void>>>
+    : public ProxyBase<void> {};
 
-  // Collapse this list into a set of keys and values consumable by
-  // TypeToTypeMap.
-  using IndexToKeyMap = metaprogramming::TypeToTypeMapFromKeyValuesTup_t<
-      metaprogramming::Flatten_t<IndexToKeyAsTuples>>;
+template <typename CharType>
+struct Proxy<CharType,
+             typename std::enable_if_t<std::is_same_v<CharType, jchar>>>
+    : public ProxyBase<jchar> {
+  using AsArg = std::tuple<char, jchar>;
+  using AsDecl = std::tuple<char, jchar>;
 
-  // When flipped, a type passed can be reverse indexed to select the same
-  // Proxy partial specialisation.
-  using KeyToIndex = metaprogramming::TypeToTypeMap_Invert<IndexToKeyMap>;
+  template <typename OverloadSelection, typename T>
+  static constexpr bool kViable = IsConvertibleKey<T>::template value<char> ||
+                                  IsConvertibleKey<T>::template value<jchar>;
+};
 
-  using Index =
-      metaprogramming::TypeToTypeMapQueryWithComparator_t<KeyToIndex,
-                                                          IsConvertibleKey<T>>;
+template <typename BooleanType>
+struct Proxy<BooleanType,
+             typename std::enable_if_t<std::is_same_v<BooleanType, jboolean>>>
+    : public ProxyBase<jboolean> {
+  using AsArg = std::tuple<jboolean, bool>;
+  using AsDecl = std::tuple<jboolean, bool>;
 
-  using Proxy_t = Proxy<Index>;
+  template <typename OverloadSelection, typename T>
+  static constexpr bool kViable =
+      IsConvertibleKey<T>::template value<jboolean> ||
+      IsConvertibleKey<T>::template value<bool>;
+};
 
-  using CDecl = typename Proxy_t::CDecl;
+template <typename LongType>
+struct Proxy<LongType,
+             typename std::enable_if_t<std::is_same_v<LongType, jlong>>>
+    : public ProxyBase<jlong> {
+  using AsArg = std::tuple<long, jlong>;
+  using AsDecl = std::tuple<long, jlong>;
 
-  template <typename Id>
-  using AsReturn_t = typename Proxy_t::template AsReturn<Id>;
+  template <typename OverloadSelection, typename T>
+  static constexpr bool kViable = IsConvertibleKey<T>::template value<long> ||
+                                  IsConvertibleKey<T>::template value<jlong>;
 
-  template <typename ParamSelection>
-  using AsArg_t = typename Proxy_t::AsArg;
+  static jlong ProxyAsArg(jlong val) { return val; }
 
-  using AsDecl_t = typename Proxy_t::AsDecl;
+  // jlong is a smaller type on ARM than x86.
+  // When jlong is not equivalent, we upcast to the wider type.
+  template <typename T,
+            typename = std::enable_if_t<std::is_same_v<T, long> &&
+                                        !std::is_same_v<jlong, long>>>
+  static jlong ProxyAsArg(T val) {
+    return jlong{val};
+  }
 };
 
-// Default Proxy, all types and values are pure passthrough.
-template <typename Key_>
-struct ProxyBase {
-  using Key = Key_;
+////////////////////////////////////////////////////////////////////////////////
+// Object Proxy Definitions.
+////////////////////////////////////////////////////////////////////////////////
+template <typename JObject>
+struct Proxy<JObject,
+             typename std::enable_if_t<std::is_same_v<JObject, jobject>>>
+    : public ProxyBase<jobject> {
+  using AsDecl = std::tuple<Object>;
+  using AsArg = std::tuple<jobject, RefBaseTag<jobject>, LoaderTag>;
 
-  using CDecl = Key_;
+  template <typename InputParamSelectionT, typename T>
+  struct ContextualViabilityHelper {
+    // TODO(b/143908983): This is overly permissive, see method_selection_test.
+    static constexpr bool kViable = std::is_same_v<T, jobject>;
+  };
 
-  template <typename>
-  using AsReturn = Key_;
+  // Old "LocalObject" form.
+  template <typename IdT,
+            template <const auto&, const auto&, const auto&> class Container,
+            const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
+  struct ContextualViabilityHelper<IdT,
+                                   Container<class_v, class_loader_v, jvm_v>> {
+    static constexpr bool kViable =
+        std::string_view{class_v.name_} == std::string_view{IdT::Val().name_};
+  };
 
-  using AsArg = std::tuple<Key_>;
-  using AsDecl = std::tuple<Key_>;
+  // New "LocalObject" form.
+  template <typename IdT, LifecycleType lifecycleType, const auto& class_v,
+            const auto& class_loader_v, const auto& jvm_v>
+  struct ContextualViabilityHelper<
+      IdT, Scoped<lifecycleType, void,
+                  JniT<jobject, class_v, class_loader_v, jvm_v>, jobject>> {
+    static constexpr bool kViable =
+        std::string_view{class_v.name_} == std::string_view{IdT::Val().name_};
+  };
+
+  template <typename IdT, typename T>
+  static constexpr bool kViable = ContextualViabilityHelper<IdT, T>::kViable;
+
+  template <typename Id>
+  struct Helper {
+    static constexpr auto kClass{Id::Val()};
+    static constexpr auto kClassLoader{Id::JniT::GetClassLoader()};
 
+    // TODO(b/174272629): Class loaders should also be enforced.
+    using type = LocalObject<kClass, kClassLoader, kDefaultJvm>;
+  };
+
+  template <typename Id>
+  using AsReturn = typename Helper<Id>::type;
+
+  static jobject ProxyAsArg(jobject obj) { return obj; };
+
+  // Applies for both local and global.
   template <typename T>
-  static auto ProxyAsArg(T&& t) {
-    return std::forward<T>(t);
-  }
+  static jobject ProxyAsArg(T& t) {
+    return jobject{t};
+  };
 
-  template <typename InputParamSelectionT, typename T>
-  static constexpr bool kViable = IsConvertibleKey_v<Key_, T>;
+  // Applies for both local and global.
+  template <typename T>
+  static jobject ProxyAsArg(T&& t) {
+    return t.Release();
+  };
 };
 
 }  // namespace jni
 
-#include <optional>
-#include <tuple>
-
-namespace jni::metaprogramming {
 
-template <typename>
-struct OptionalTup {};
+namespace jni {
 
-// Takes a _tuple_ of types and returns a tuple with the same types except
-// wrapped in std::optional.
-template <typename... Ts>
-struct OptionalTup<std::tuple<Ts...>> {
-  using type = std::tuple<std::optional<Ts>...>;
+template <typename JniT, size_t field_idx_>
+struct FieldSelection {
+  using IdT = Id<JniT, IdType::FIELD, field_idx_>;
+  static constexpr IdType kRetTypeId = IdType::FIELD;
 };
 
-template <typename... Ts>
-using OptionalTup_t = typename OptionalTup<Ts...>::type;
-
-}  // namespace jni::metaprogramming
+}  // namespace jni
 
-#include <utility>
+#include <atomic>
+#include <mutex>  // NOLINT
+#include <vector>
 
 namespace jni {
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0: Static primitive types (e.g. int).
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct FieldHelper<jboolean, 0, true, void> {
-  static inline jboolean GetValue(const jclass clazz,
-                                  const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticBooleanField(clazz, field_ref_);
-  }
+// See JvmRef::~JvmRef.
+static std::vector<metaprogramming::DoubleLockedValue<jclass>*>&
+GetDefaultLoadedClassList() {
+  static auto* ret_val =
+      new std::vector<metaprogramming::DoubleLockedValue<jclass>*>{};
+  return *ret_val;
+}
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jboolean&& value) {
-    jni::JniEnv::GetEnv()->SetStaticBooleanField(clazz, field_ref_, value);
-  }
-};
+static inline jclass LoadClassFromObject(const char* name, jobject object_ref);
 
-template <>
-struct FieldHelper<jbyte, 0, true, void> {
-  static inline jbyte GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticByteField(clazz, field_ref_);
-  }
+// Represents a a jclass instance for a specific class. 4 flavours exist:
+//   1) Default JVM, default class loader.
+//   2) Non-default JVM, default class loader.
+//   3) Default JVM, non-default class loader.
+//   4) Non-default JVM, non default class loader (i.e. fully specified).
+//
+// Use |ClassRef_t| to provide |JniT| in its minimal form.
+template <typename JniT>
+class ClassRef {
+ public:
+  static_assert(std::is_same_v<JniT, typename JniT::MinimallySpanningType>,
+                "JniT must be in its minimal form for best caching.");
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jbyte&& value) {
-    return jni::JniEnv::GetEnv()->SetStaticByteField(clazz, field_ref_, value);
+  template <typename Lambda>
+  static void PrimeJClassFromClassLoader(Lambda lambda) {
+    class_ref_.LoadAndMaybeInit(lambda);
   }
-};
 
-template <>
-struct FieldHelper<jchar, 0, true, void> {
-  static inline jchar GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticCharField(clazz, field_ref_);
-  }
+  static jclass GetAndMaybeLoadClassRef(
+      jobject optional_object_to_build_loader_from) {
+    // For the default classloader, storage in function local static.
+    if constexpr (JniT::GetClassLoader() == kDefaultClassLoader) {
+      static metaprogramming::DoubleLockedValue<jclass> return_value;
+      return return_value.LoadAndMaybeInit([]() {
+        GetDefaultLoadedClassList().push_back(&return_value);
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jchar&& value) {
-    jni::JniEnv::GetEnv()->SetStaticCharField(clazz, field_ref_, value);
+        return static_cast<jclass>(
+            LifecycleHelper<jobject, LifecycleType::GLOBAL>::Promote(
+                JniHelper::FindClass(JniT::kName.data())));
+      });
+    } else {
+      // For non default classloader, storage in class member.
+      return class_ref_.LoadAndMaybeInit([=]() {
+        return LoadClassFromObject(JniT::kNameWithDots.data(),
+                                   optional_object_to_build_loader_from);
+      });
+    }
   }
-};
 
-template <>
-struct FieldHelper<jshort, 0, true, void> {
-  static inline jshort GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticShortField(clazz, field_ref_);
+  static jclass GetAlreadyLoadedClassRef() {
+    return class_ref_.LoadAndMaybeInit([]() { return jclass{0}; });
   }
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jshort&& value) {
-    jni::JniEnv::GetEnv()->SetStaticShortField(clazz, field_ref_, value);
+  static void MaybeReleaseClassRef() {
+    class_ref_.Reset([](jclass maybe_loaded_class) {
+      LifecycleHelper<jclass, LifecycleType::GLOBAL>::Delete(
+          maybe_loaded_class);
+    });
   }
+
+ private:
+  // A global reference to a jclass object that is returned from FindClass.
+  // The variable has static storage because ClassIDs are static to the lifetime
+  // of a JVM.  See GetAndMaybeLoadClassRef and MaybeReleaseClassRef.
+  static inline metaprogramming::DoubleLockedValue<jclass> class_ref_;
 };
 
-template <>
-struct FieldHelper<jint, 0, true, void> {
-  static inline jint GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticIntField(clazz, field_ref_);
-  }
+// When we get an object_ref_ as a return value from a Java method, it may be
+// an instance of a subclass of ClassRefT. In this case, if we directly used
+// the object_ref_'s class, then we might incorrectly get member information
+// for the subclass instead of the original class. However, the original class
+// should still be loadable from the subclass's class loader, so we load the
+// ClassRef explicitly by class name.
+static inline jclass LoadClassFromObject(const char* name, jobject object_ref) {
+  // We cannot refer to the wrapper MethodRefs here, so we just manually use
+  // the class loader through JNI.
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jint&& value) {
-    jni::JniEnv::GetEnv()->SetStaticIntField(clazz, field_ref_, value);
-  }
-};
+  // Gets the ClassLoader of java/lang/class (the primordial loader).
+  // Note, these aren't static methods, they're member methods to be invoked
+  // on the object's class itself.  The class may not have been loaded yet,
+  // and all you have is a jobject
+  jclass java_lang_class_jclass =
+      ClassRef<JniT<jobject, kJavaLangClass>>::GetAndMaybeLoadClassRef(nullptr);
 
-template <>
-struct FieldHelper<jlong, 0, true, void> {
-  static inline jlong GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticLongField(clazz, field_ref_);
-  }
+  jclass java_lang_class_loader_jclass =
+      ClassRef<JniT<jobject, kJavaLangClassLoader>>::GetAndMaybeLoadClassRef(
+          nullptr);
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jlong&& value) {
-    jni::JniEnv::GetEnv()->SetStaticLongField(clazz, field_ref_, value);
-  }
-};
+  jclass class_of_object_jclass = JniHelper::GetObjectClass(object_ref);
 
-template <>
-struct FieldHelper<jfloat, 0, true, void> {
-  static inline jfloat GetValue(const jclass clazz, const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticFloatField(clazz, field_ref_);
-  }
+  jmethodID get_class_loader_jmethod = JniHelper::GetMethodID(
+      java_lang_class_jclass, "getClassLoader", "()Ljava/lang/ClassLoader;");
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jfloat&& value) {
-    jni::JniEnv::GetEnv()->SetStaticFloatField(clazz, field_ref_, value);
-  }
-};
+  jobject object_ref_class_loader_jobject =
+      InvokeHelper<jobject, 1, false>::Invoke(class_of_object_jclass, nullptr,
+                                              get_class_loader_jmethod);
 
-template <>
-struct FieldHelper<jdouble, 0, true, void> {
-  static inline jdouble GetValue(const jclass clazz,
-                                 const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticDoubleField(clazz, field_ref_);
-  }
+  jmethodID load_class_jmethod =
+      JniHelper::GetMethodID(java_lang_class_loader_jclass, "loadClass",
+                             "(Ljava/lang/String;)Ljava/lang/Class;");
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jdouble&& value) {
-    jni::JniEnv::GetEnv()->SetStaticDoubleField(clazz, field_ref_, value);
-  }
-};
+  jstring name_string =
+      LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(name);
+  jobject local_jclass_of_correct_loader =
+      InvokeHelper<jobject, 1, false>::Invoke(object_ref_class_loader_jobject,
+                                              nullptr, load_class_jmethod,
+                                              name_string);
+  jobject promote_jclass_of_correct_loader =
+      LifecycleHelper<jobject, LifecycleType::GLOBAL>::Promote(
+          local_jclass_of_correct_loader);
 
-template <>
-struct FieldHelper<jobject, 0, true, void> {
-  static inline jobject GetValue(const jclass clazz,
-                                 const jfieldID field_ref_) {
-    return jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_);
-  }
+  LifecycleHelper<jobject, LifecycleType::LOCAL>::Delete(
+      object_ref_class_loader_jobject);
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jobject&& new_value) {
-    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, new_value);
-  }
-};
+  return static_cast<jclass>(promote_jclass_of_correct_loader);
+}
 
-template <>
-struct FieldHelper<jstring, 0, true, void> {
-  static inline jstring GetValue(const jclass clazz,
-                                 const jfieldID field_ref_) {
-    return reinterpret_cast<jstring>(
-        jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_));
-  }
+template <typename JniT>
+using ClassRef_t = ClassRef<typename JniT::MinimallySpanningType>;
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jstring&& new_value) {
-    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, new_value);
-  }
-};
+}  // namespace jni
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1: Static single dimension arrays (e.g. int[]).
-////////////////////////////////////////////////////////////////////////////////
-template <typename ArrayType>
-struct StaticBaseFieldArrayHelper {
-  static inline ArrayType GetValue(const jobject object_ref,
-                                   const jfieldID field_ref_) {
-    return static_cast<ArrayType>(
-        jni::JniEnv::GetEnv()->GetObjectField(object_ref, field_ref_));
-  }
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+
+namespace jni::metaprogramming {
+
+// "Unfurls" an index sequence onto a container, and provides convenience
+// helpers
+//
+// |type| is a variadic metafunction that generates a tuple for each type
+//  where each type is Container<Idx, Ts...> for [0, Is...).
+//    i.e. std::tuple<Container<0, Ts...>, Container<1, Ts...>, ...>
+//
+// |val| is a variadic data member that is the fold of the val member of each
+//   element of |type|. If |use_conjunction_fold_on_val| is true, the fold
+//   operator will be &&, otherwise it will be ||.
+template <template <std::size_t, typename...> class Container, std::size_t Is,
+          bool use_conjunction_fold_on_val = true>
+struct Unfurl {
+  template <typename Ts, typename Indexes>
+  struct Helper;
 
-  static inline void SetValue(const jobject object_ref,
-                              const jfieldID field_ref_, ArrayType&& value) {
-    jni::JniEnv::GetEnv()->SetObjectField(object_ref, field_ref_, value);
-  }
-};
+  template <typename... Ts, std::size_t... Indices>
+  struct Helper<std::tuple<Ts...>, std::index_sequence<Indices...>> {
+    using type = std::tuple<Container<Indices, Ts...>...>;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jbooleanArray> {};
+    static constexpr bool val = use_conjunction_fold_on_val
+                                    ? (Container<Indices, Ts...>::val && ...)
+                                    : (Container<Indices, Ts...>::val || ...);
+  };
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jbyteArray> {};
+  template <typename... Ts>
+  using type =
+      typename Helper<std::tuple<Ts...>, std::make_index_sequence<Is>>::type;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jcharArray> {};
+  template <typename... Ts>
+  static constexpr bool val =
+      Helper<std::tuple<Ts...>, std::make_index_sequence<Is>>::val;
+};
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jshortArray> {};
+template <std::size_t Is, template <std::size_t, typename...> class Container,
+          typename... Ts>
+using Unfurl_t = typename Unfurl<Container, Is>::template type<Ts...>;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jint>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jintArray> {};
+template <std::size_t Is, template <std::size_t, typename...> class Container,
+          typename... Ts>
+static constexpr bool UnfurlConjunction_v =
+    Unfurl<Container, Is, true>::template val<Ts...>;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jlongArray> {};
+template <std::size_t Is, template <std::size_t, typename...> class Container,
+          typename... Ts>
+static constexpr bool UnfurlDisjunction_v =
+    Unfurl<Container, Is, false>::template val<Ts...>;
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jfloatArray> {};
+}  // namespace jni::metaprogramming
 
-template <std::size_t kRank>
-struct FieldHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, true, void>
-    : StaticBaseFieldArrayHelper<jdoubleArray> {};
+namespace jni::metaprogramming {
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1: Static jobjects.
-// Rank 2+: Static multi-dimension arrays (e.g. int[][], int[][][]).
-////////////////////////////////////////////////////////////////////////////////
-template <typename T, std::size_t kRank>
-struct FieldHelper<
-    T, kRank, true,
-    std::enable_if_t<(std::is_same_v<jobject, T> || (kRank > 1))>> {
-  static inline jobjectArray GetValue(const jclass clazz,
-                                      const jfieldID field_ref_) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->GetStaticObjectField(clazz, field_ref_));
-  }
+struct Max {
+  template <typename T1, typename T2>
+  struct Helper;
 
-  static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
-                              jobjectArray&& value) {
-    jni::JniEnv::GetEnv()->SetStaticObjectField(clazz, field_ref_, value);
-  }
+  template <const auto v1, const auto v2>
+  struct Helper<Val<v1>, Val<v2>> {
+    using type = std::conditional_t<(v1 > v2), Val<v1>, Val<v2>>;
+  };
+
+  template <typename T1, typename T2>
+  using type = typename Helper<T1, T2>::type;
 };
 
-}  // namespace jni
+template <typename T1, typename T2>
+using Max_t = typename Max::type<T1, T2>;
 
-#include <cstddef>
-#include <utility>
+template <typename T1, typename T2>
+static constexpr auto Max_v = Max_t<T1, T2>::val;
 
-namespace jni {
+struct Min {
+  template <typename T1, typename T2>
+  struct Helper;
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0 type (aka void).
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct InvokeHelper<void, 0, true> {
-  template <typename... Ts>
-  static void Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    jni::JniEnv::GetEnv()->CallStaticVoidMethod(clazz, method_id,
-                                                std::forward<Ts>(ts)...);
-  }
-};
+  template <const auto v1, const auto v2>
+  struct Helper<Val<v1>, Val<v2>> {
+    using type = std::conditional_t<(v1 < v2), Val<v1>, Val<v2>>;
+  };
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 0 types, i.e. the primitive type itself (e.g. int).
-////////////////////////////////////////////////////////////////////////////////
-template <>
-struct InvokeHelper<jboolean, 0, true> {
-  template <typename... Ts>
-  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
-                         Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticBooleanMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
+  template <typename T1, typename T2>
+  using type = typename Helper<T1, T2>::type;
 };
 
-template <>
-struct InvokeHelper<jbyte, 0, true> {
-  template <typename... Ts>
-  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
-                         Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticByteMethod(clazz, method_id,
-                                                       std::forward<Ts>(ts)...);
-  }
-};
+template <typename T1, typename T2>
+using Min_t = typename Min::type<T1, T2>;
 
-template <>
-struct InvokeHelper<jchar, 0, true> {
-  template <typename... Ts>
-  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
-                         Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticCharMethod(clazz, method_id,
-                                                       std::forward<Ts>(ts)...);
-  }
-};
+template <typename T1, typename T2>
+static constexpr auto Min_v = Min_t<T1, T2>::val;
 
-template <>
-struct InvokeHelper<jshort, 0, true> {
-  template <typename... Ts>
-  static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
-                         Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticShortMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
-};
+}  // namespace jni::metaprogramming
 
-template <>
-struct InvokeHelper<jint, 0, true> {
-  template <typename... Ts>
-  static jint Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticIntMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...);
-  }
-};
+#include <tuple>
+#include <type_traits>
 
-template <>
-struct InvokeHelper<jlong, 0, true> {
-  template <typename... Ts>
-  static jlong Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticLongMethod(clazz, method_id,
-                                                       std::forward<Ts>(ts)...);
-  }
-};
+namespace jni::metaprogramming {
 
-template <>
-struct InvokeHelper<jfloat, 0, true> {
-  template <typename... Ts>
-  static jfloat Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticFloatMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
-};
+// Metafunction for querying traits return and argument types of a function.
+template <typename>
+struct FunctionTraits;
 
-template <>
-struct InvokeHelper<jdouble, 0, true> {
-  template <typename... Ts>
-  static jdouble Invoke(jobject, jclass clazz, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticDoubleMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
-};
+// Partial specialisation for functions.
+template <typename Return_, typename... Args>
+struct FunctionTraits<Return_(Args...)> {
+  using Return = Return_;
+  using ArgsTup = std::tuple<Args...>;
 
-template <>
-struct InvokeHelper<jobject, 0, true> {
-  // This always returns a local reference which should be embedded in type
-  // information wherever this is used.
-  template <typename... Ts>
-  static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticObjectMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
-};
+  static constexpr std::size_t arity = sizeof...(Args);
 
-template <>
-struct InvokeHelper<jstring, 0, true> {
-  template <typename... Ts>
-  static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
-                        Ts&&... ts) {
-    return jni::JniEnv::GetEnv()->CallStaticObjectMethod(
-        clazz, method_id, std::forward<Ts>(ts)...);
-  }
+  template <std::size_t N>
+  struct Argument {
+    static_assert(N < arity, "Parameter index exceeds argument count.");
+    using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
+  };
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 1 types, i.e. single dimension arrays (e.g. int[]).
-////////////////////////////////////////////////////////////////////////////////
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, true> {
-  template <typename... Ts>
-  static jbooleanArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                              Ts&&... ts) {
-    return static_cast<jbooleanArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+// Partial specialisation for function pointer.
+template <typename R, typename... Args>
+struct FunctionTraits<R (*)(Args...)> : public FunctionTraits<R(Args...)> {};
+
+// Member function pointer
+template <class C, class R, class... Args>
+struct FunctionTraits<R (C::*)(Args...)>
+    : public FunctionTraits<R(C&, Args...)> {};
+
+// const member function pointer
+template <class C, class R, class... Args>
+struct FunctionTraits<R (C::*)(Args...) const>
+    : public FunctionTraits<R(C&, Args...)> {};
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, true> {
-  template <typename... Ts>
-  static jbyteArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jbyteArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+// Member object pointer
+template <class C, class R>
+struct FunctionTraits<R(C::*)> : public FunctionTraits<R(C&)> {};
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, true> {
-  template <typename... Ts>
-  static jcharArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jcharArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+template <typename T>
+using FunctionTraitsReturn_t = typename FunctionTraits<T>::Return;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, true> {
-  template <typename... Ts>
-  static jshortArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                            Ts&&... ts) {
-    return static_cast<jshortArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+template <typename T, std::size_t argument_idx>
+using FunctionTraitsArg_t =
+    typename FunctionTraits<T>::template Argument<argument_idx>::type;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, true> {
-  template <typename... Ts>
-  static jintArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                          Ts&&... ts) {
-    return static_cast<jintArray>(jni::JniEnv::GetEnv()->CallStaticObjectMethod(
-        clazz, method_id, std::forward<Ts>(ts)...));
-  }
-};
+}  // namespace jni::metaprogramming
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, true> {
-  template <typename... Ts>
-  static jfloatArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                            Ts&&... ts) {
-    return static_cast<jfloatArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+#include <tuple>
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, true> {
-  template <typename... Ts>
-  static jdoubleArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jdoubleArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+namespace jni::metaprogramming {
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, true> {
-  template <typename... Ts>
-  static jlongArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                           Ts&&... ts) {
-    return static_cast<jlongArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+// Call takes a tuple of arguments and returns a tuple of elements
+// dereferenced once (with no arguments). Eventually, this should have
+// the pack discriminated forwarding (to optionally pass args).
+struct Call {
+  template <typename T>
+  struct Helper;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, true> {
-  // Arrays of arrays (which this invoke represents) return object arrays
-  // (arrays themselves are objects, ergo object arrays).
   template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+  struct Helper<std::tuple<Ts...>> {
+    using type = std::tuple<typename Ts::type...>;
+  };
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
+  template <typename T>
+  using type = typename Helper<T>::type;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Rank 2+ types, i.e. multi-dimension arrays (e.g. int[][], int[][][]).
-////////////////////////////////////////////////////////////////////////////////
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+template <typename T>
+using Call_t = typename Call::type<T>;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+}  // namespace jni::metaprogramming
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+#include <mutex>
+#include <tuple>
+#include <utility>
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+namespace jni {
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+// See JvmRef::~JvmRef.
+static inline auto& GetDefaultLoadedMethodList() {
+  static auto* ret_val =
+      new std::vector<metaprogramming::DoubleLockedValue<jmethodID>*>{};
+  return *ret_val;
+}
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+template <typename IdT_, IdType kReturnIDType>
+struct OverloadRef {
+  using IdT = IdT_;
+  using ReturnIdT = typename IdT::template ChangeIdType<kReturnIDType>;
+  using ReturnProxied =
+      Return_t<typename ReturnIdT::MaterializeCDeclT, ReturnIdT>;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+  static jmethodID GetMethodID(jclass clazz) {
+    static jni::metaprogramming::DoubleLockedValue<jmethodID> return_value;
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
-  }
-};
+    return return_value.LoadAndMaybeInit([=]() {
+      if constexpr (IdT_::JniT::GetClassLoader() == kDefaultClassLoader) {
+        GetDefaultLoadedMethodList().push_back(&return_value);
+      }
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, true> {
-  // Arrays of arrays (which this invoke represents) return object arrays
-  // (arrays themselves are objects, ergo object arrays).
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
+      if constexpr (IdT::kIsStatic) {
+        return jni::JniHelper::GetStaticMethodID(clazz, IdT::Name(),
+                                                 Signature_v<IdT>.data());
+      } else {
+        return jni::JniHelper::GetMethodID(clazz, IdT::Name(),
+                                           Signature_v<IdT>.data());
+      }
+    });
   }
-};
 
-template <std::size_t kRank>
-struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, true> {
-  template <typename... Ts>
-  static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
-                             Ts&&... ts) {
-    return static_cast<jobjectArray>(
-        jni::JniEnv::GetEnv()->CallStaticObjectMethod(clazz, method_id,
-                                                      std::forward<Ts>(ts)...));
+  template <typename... Params>
+  static ReturnProxied Invoke(jclass clazz, jobject object,
+                              Params&&... params) {
+    constexpr std::size_t kRank = ReturnIdT::kRank;
+    constexpr bool kStatic = ReturnIdT::kIsStatic;
+    const jmethodID mthd = OverloadRef::GetMethodID(clazz);
+
+    if constexpr (std::is_same_v<ReturnProxied, void>) {
+      return InvokeHelper<void, kRank, kStatic>::Invoke(
+          object, clazz, mthd,
+          Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...);
+    } else if constexpr (IdT::kIsConstructor) {
+      return ReturnProxied{
+          LifecycleHelper<jobject, LifecycleType::LOCAL>::Construct(
+              clazz, mthd,
+              Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...)};
+    } else {
+      return static_cast<ReturnProxied>(
+          InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
+              object, clazz, mthd,
+              Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...));
+    }
   }
 };
 
 }  // namespace jni
 
-#include <iterator>
-#include <string>
-#include <type_traits>
+
+#include <mutex>
+#include <string_view>
+#include <tuple>
+#include <utility>
 
 namespace jni {
 
-class LocalString;
-class GlobalString;
+// See JvmRef::~JvmRef.
+static inline auto& GetDefaultLoadedFieldList() {
+  static auto* ret_val =
+      new std::vector<metaprogramming::DoubleLockedValue<jfieldID>*>{};
+  return *ret_val;
+}
 
-template <typename SpanType, std::size_t kRank, const auto& class_v_,
-          const auto& class_loader_v_, const auto& jvm_v_>
-class LocalArray;
+// Represents a live instance of Field I's definition.
+//
+// Note, this class performs no cleanup on destruction.  jFieldIDs are static
+// throughout the duration of a JVM's life, see JvmRef for teardown.
+template <typename JniT, IdType field_type, std::size_t I>
+class FieldRef {
+ public:
+  using IdT = Id<JniT, field_type, I>;
+  using FieldSelectionT = FieldSelection<JniT, I>;
 
-template <typename JString>
-struct Proxy<JString,
-             typename std::enable_if_t<std::is_same_v<JString, jstring>>>
-    : public ProxyBase<JString> {
-  template <typename Id, std::size_t kRank>
-  struct Helper {
-    using type = LocalArray<jstring, kRank, kJavaLangString,
-                            kDefaultClassLoader, kDefaultJvm>;
-  };
+  explicit FieldRef(jclass class_ref, jobject object_ref)
+      : class_ref_(class_ref), object_ref_(object_ref) {}
 
-  template <typename Id>
-  struct Helper<Id, 0> {
-    using type = LocalString;
-  };
+  FieldRef(const FieldRef&) = delete;
+  FieldRef(const FieldRef&&) = delete;
+  void operator=(const FieldRef&) = delete;
 
-  using AsArg = std::tuple<std::string, jstring, char*, const char*,
-                           std::string_view, RefBaseTag<jstring>>;
+  // This method is thread safe.
+  static jfieldID GetFieldID(jclass clazz) {
+    static jni::metaprogramming::DoubleLockedValue<jfieldID> return_value;
 
-  template <typename Id>
-  using AsReturn = typename Helper<Id, Id::kRank>::type;
+    return return_value.LoadAndMaybeInit([=]() {
+      if constexpr (JniT::class_loader_v == kDefaultClassLoader) {
+        GetDefaultLoadedFieldList().push_back(&return_value);
+      }
 
-  template <typename OverloadSelection, typename T>
-  static constexpr bool kViable =
-      IsConvertibleKey<T>::template value<std::string> ||
-      IsConvertibleKey<T>::template value<jstring> ||
-      IsConvertibleKey<T>::template value<char*> ||
-      IsConvertibleKey<T>::template value<const char*> ||
-      IsConvertibleKey<T>::template value<std::string_view> ||
-      std::is_same_v<T, LocalString> || std::is_same_v<T, GlobalString>;
+      if constexpr (IdT::kIsStatic) {
+        return jni::JniHelper::GetStaticFieldID(clazz, IdT::Name(),
+                                                Signature_v<IdT>.data());
+      } else {
+        return jni::JniHelper::GetFieldID(clazz, IdT::Name(),
+                                          Signature_v<IdT>.data());
+      }
+    });
+  }
 
-  // These leak local instances of strings.  Usually, RAII mechanisms would
-  // correctly release local instances, but here we are stripping that so it can
-  // be used in a method.  This could be obviated by wrapping the calling scope
-  // in a local stack frame.
-  static jstring ProxyAsArg(jstring s) { return s; }
+  using ReturnProxied = Return_t<typename IdT::MaterializeCDeclT, IdT>;
 
-  template <typename T,
-            typename = std::enable_if_t<std::is_same_v<T, const char*> ||
-                                        std::is_same_v<T, std::string> ||
-                                        std::is_same_v<T, std::string_view>>>
-  static jstring ProxyAsArg(T s) {
-    if constexpr (std::is_same_v<T, const char*>) {
-      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(s);
+  const auto& SelfVal() {
+    if constexpr (IdT::kIsStatic) {
+      return class_ref_;
     } else {
-      return LifecycleHelper<jstring, LifecycleType::LOCAL>::Construct(
-          s.data());
+      return object_ref_;
     }
   }
 
-  template <typename T,
-            typename = std::enable_if_t<std::is_same_v<T, GlobalString> ||
-                                        std::is_same_v<T, LocalString>>>
-  static jstring ProxyAsArg(T& t) {
-    return jstring{t};
+  ReturnProxied Get() {
+    return {FieldHelper<CDecl_t<typename IdT::RawValT>, IdT::kRank,
+                        IdT::kIsStatic>::GetValue(SelfVal(),
+                                                  GetFieldID(class_ref_))};
   }
 
-  template <typename T,
-            typename = std::enable_if_t<std::is_same_v<T, GlobalString> ||
-                                        std::is_same_v<T, LocalString>>>
-  static jstring ProxyAsArg(T&& t) {
-    return t.Release();
+  template <typename T>
+  void Set(T&& value) {
+    FieldHelper<CDecl_t<typename IdT::RawValT>, IdT::kRank,
+                IdT::kIsStatic>::SetValue(SelfVal(), GetFieldID(class_ref_),
+                                          Proxy_t<T>::ProxyAsArg(
+                                              std::forward<T>(value)));
   }
+
+ private:
+  const jclass class_ref_;
+  const jobject object_ref_;
 };
 
 }  // namespace jni
 
-namespace jni {
+namespace jni::metaprogramming {
 
-template <typename Overload>
-struct ArrayHelper;
+template <char sought>
+struct StringContains {
+  template <const std::string_view& str, typename IndexSequence>
+  struct Helper;
 
-template <typename SpanType>
-struct ArrayRefPrimitiveTag;
+  template <const std::string_view& str, std::size_t... Is>
+  struct Helper<str, std::index_sequence<Is...>> {
+    static constexpr bool val = ((str[Is] == sought) || ...);
+  };
 
-template <typename SpanType, std::size_t kRank, const auto& class_v_,
-          const auto& class_loader_v_, const auto& jvm_v_>
-class LocalArray;
+  template <const std::string_view& str>
+  static constexpr bool val =
+      Helper<str, std::make_index_sequence<str.length()>>::val;
+};
 
-template <typename JArrayType>
-struct Proxy<JArrayType, typename std::enable_if_t<
-                             std::is_convertible_v<JArrayType, jarray>>>
-    : public ProxyBase<JArrayType> {
-  // Non-array primitive type (e.g. jintArray => jint).
-  using CDecl = ArrayToRegularTypeMap_t<JArrayType>;
+template <const std::string_view& str, char sought>
+static constexpr bool StringContains_v =
+    StringContains<sought>::template val<str>;
 
-  // Primitive Array Types (e.g. if JArrayType is jintarray and T is too).
-  template <typename ParamSelection, typename T, typename Enable = void>
+}  // namespace jni::metaprogramming
+
+namespace jni::metaprogramming {
+
+enum class PackType {
+  NOT_CONTAINER,
+  TYPES,
+  AUTO,
+  AUTO_REF,
+  CONST_AUTO_REF,
+};
+
+// Metafunction to discrimate the underlying pack type of a Container.
+// Note: This interface is subject to change as the auto partial specialisations
+// cannot discriminate on void.
+struct PackDiscrimator {
+  template <typename T>
   struct Helper {
-    static constexpr bool val =
-        (std::is_same_v<T, JArrayType> && ParamSelection::kRank == 1) ||
-        (std::is_same_v<T, jobjectArray> && ParamSelection::kRank >= 2);
+    static constexpr PackType val = PackType::NOT_CONTAINER;
   };
 
-  // LocalArray.
-  template <typename ParamSelection, typename SpanType, std::size_t kRank,
-            const auto& class_v_, const auto& class_loader_v_,
-            const auto& jvm_v_>
-  struct Helper<ParamSelection, LocalArray<SpanType, kRank, class_v_,
-                                           class_loader_v_, jvm_v_>> {
-    static constexpr auto param_copy = FullArrayStripV(ParamSelection::Val());
-
-    static constexpr bool val =
-        (kRank == ParamSelection::kRank) &&
-        (std::is_same_v<SpanType, typename ParamSelection::RawValT> ||
-         (std::is_same_v<SpanType, jobjectArray> &&
-          ParamSelection::kRank >= 2) ||
-         (std::string_view{class_v_.name_} == NameOrNothing_v<param_copy>));
+  template <template <typename...> class Container, typename... Ts>
+  struct Helper<Container<Ts...>> {
+    static constexpr PackType val = PackType::TYPES;
   };
 
-  template <typename ParamSelection, typename T>
-  static constexpr bool kViable = Helper<ParamSelection, T>::val;
+  template <template <auto...> class Container, auto... Vs>
+  struct Helper<Container<Vs...>> {
+    static constexpr PackType val = PackType::AUTO;
+  };
 
-  using AsDecl = std::tuple<ArrayTag<JArrayType>>;
-  using AsArg = std::tuple<JArrayType, RefBaseTag<JArrayType>,
-                           ArrayTag<JArrayType>, ArrayRefPrimitiveTag<CDecl>>;
+  template <template <auto&...> class Container, auto&... Vs>
+  struct Helper<Container<Vs...>> {
+    static constexpr PackType val = PackType::AUTO_REF;
+  };
 
-  template <typename Id>
-  using AsReturn = typename ArrayHelper<Id>::AsReturn;
+  template <template <const auto&...> class Container, const auto&... Vs>
+  struct Helper<Container<Vs...>> {
+    static constexpr PackType val = PackType::CONST_AUTO_REF;
+  };
 
-  static JArrayType ProxyAsArg(JArrayType arr) { return arr; };
+  template <typename T>
+  static constexpr PackType val = Helper<T>::val;
+};
 
+template <typename T>
+static constexpr PackType PackDiscriminator_e =
+    PackDiscrimator::template val<T>;
+
+// Metafunction to forward a containerized pack to a compatible container.
+template <template <template <typename...> class> class TypesContainer,
+          template <template <auto...> class> class AutoContainer,
+          template <template <const auto&...> class>
+          class ConstAutoRefContainer>
+struct PackDiscriminatedForward {
   template <typename T>
-  static JArrayType ProxyAsArg(const T& t) {
-    return JArrayType{t};
+  struct Helper;
+
+  template <template <typename...> class Container, typename... Ts>
+  struct Helper<Container<Ts...>> {
+    using type =
+        typename TypesContainer<Container>::template type<Container<Ts...>>;
+  };
+
+  template <template <auto...> class Container, auto... vs>
+  struct Helper<Container<vs...>> {
+    using type =
+        typename AutoContainer<Container>::template type<Container<vs...>>;
   };
 
-  template <typename T, typename = std::enable_if_t<
-                            std::is_base_of_v<RefBaseTag<JArrayType>, T>>>
-  static JArrayType ProxyAsArg(T&& t) {
-    return t.Release();
-  };
+  template <template <const auto&...> class Container, const auto&... vs>
+  struct Helper<Container<vs...>> {
+    using type = typename ConstAutoRefContainer<Container>::template type<
+        Container<vs...>>;
+  };
+
+  template <typename T>
+  using type = typename Helper<T>::type;
+};
+
+}  // namespace jni::metaprogramming
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+namespace jni {
+
+// Viablility helper for an exact parameter.
+template <std::size_t I, typename IdT, typename ValkReturnIDType,
+          typename... Ts>
+struct Viable {
+  static constexpr IdType kReturnIDType = ValkReturnIDType::val;
+  using IdTmp = typename IdT::template ChangeIdType<kReturnIDType>;
+  using IdTParamType = typename IdTmp::template ChangeIdx<2, I>;
+
+  static constexpr bool val =
+      Proxy_t<typename IdTParamType::UnstrippedRawVal>::template kViable<
+          IdTParamType,
+          metaprogramming::TypeOfNthElement_t<I, std::decay_t<Ts>...>>;
+};
+
+template <typename OverloadId, IdType kReturnIDType>
+struct ArgumentValidate {
+  // Helper to prevents instantiating mismatching size unrolls.
+  template <typename... Ts>
+  static constexpr bool ViableHelper() {
+    if constexpr (sizeof...(Ts) == OverloadId::kNumParams) {
+      return metaprogramming::UnfurlConjunction_v<
+          OverloadId::kNumParams, Viable, OverloadId,
+          metaprogramming::Val_t<kReturnIDType>, Ts...>;
+    } else {
+      return false;
+    }
+  }
+
+  template <typename... Ts>
+  static constexpr bool kValid = ViableHelper<Ts...>();
+};
+
+template <typename IdT_, IdType kReturnIDType>
+struct OverloadSelection {
+  using IdT = IdT_;
+
+  template <typename... Ts>
+  static constexpr bool OverloadViable() {
+    return ArgumentValidate<IdT, kReturnIDType>::template kValid<Ts...>;
+  }
+
+  template <typename... Ts>
+  static constexpr size_t OverloadIdxIfViable() {
+    return OverloadViable<Ts...>() ? IdT::kSecondaryIdx : kNoIdx;
+  }
 };
 
-// This must be defined outside of Proxy so implicit definition doesn't occur.
-template <typename IdT>
-struct ArrayHelper {
-  template <const auto& t>
-  struct Helper {
-    static constexpr auto val = FullArrayStripV(t.raw_);
+template <typename IdT_, IdType kIDType = IdType::OVERLOAD,
+          IdType kReturnIDType = IdType::OVERLOAD_PARAM>
+struct MethodSelection {
+  using IdT = IdT_;
+  using JniT = typename IdT::JniT;
 
-    using StrippedCDecl = CDecl_t<std::decay_t<decltype(val)>>;
-    using ConvertedCDecl = RegularToArrayTypeMap_t<StrippedCDecl>;
+  template <std::size_t I, typename... Ts>
+  struct Helper {
+    using type = metaprogramming::Val_t<OverloadSelection<
+        Id<JniT, kIDType, IdT::kIdx, I>,
+        kReturnIDType>::template OverloadIdxIfViable<Ts...>()>;
   };
 
-  static constexpr auto kVal{IdT::Materialize()};
+  template <typename... Ts>
+  static constexpr std::size_t kIdxForTs = metaprogramming::ReduceAsPack_t<
+      metaprogramming::Min, metaprogramming::Call_t<metaprogramming::Unfurl_t<
+                                IdT::NumParams(), Helper, Ts...>>>::val;
 
-  static constexpr auto LocalArrayBuildFromArray() {
-    using RawT = typename IdT::RawMaterializeT;
-    constexpr std::size_t kRank = IdT::kMaterializedRank;
+  template <typename... Ts>
+  using FindOverloadSelection =
+      OverloadSelection<Id<JniT, kIDType, IdT::kIdx, kIdxForTs<Ts...>>,
+                        kReturnIDType>;
 
-    if constexpr (!std::is_same_v<CDecl_t<RawT>, jobject>) {
-      return LocalArray<RawT, kRank, kNoClassSpecified, kDefaultClassLoader,
-                        kDefaultJvm>{nullptr};
-    } else {
-      return LocalArray<jobject, kRank, Helper<kVal>::val, kDefaultClassLoader,
-                        kDefaultJvm>{jobjectArray{nullptr}};
-    }
+  template <typename... Ts>
+  static constexpr bool ArgSetViable() {
+    return kIdxForTs<Ts...> != kNoIdx;
   }
+};
 
-  using StrippedCDecl = typename Helper<kVal>::StrippedCDecl;
-  using ConvertedCDecl = typename Helper<kVal>::ConvertedCDecl;
+template <typename IdT, IdType kIDType, IdType kReturnIDType, typename... Args>
+struct OverloadSelector {
+  using OverloadSelectionForArgs = typename MethodSelection<
+      IdT, kIDType, kReturnIDType>::template FindOverloadSelection<Args...>;
 
-  using AsReturn = decltype(LocalArrayBuildFromArray());
+  using OverloadRef =
+      OverloadRef<Id<typename IdT::JniT, kIDType, IdT::kIdx,
+                     OverloadSelectionForArgs::IdT::kSecondaryIdx>,
+                  kReturnIDType>;
+
+  static constexpr bool kIsValidArgSet =
+      MethodSelection<IdT, kIDType,
+                      kReturnIDType>::template ArgSetViable<Args...>();
 };
 
 }  // namespace jni
 
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
 
-namespace jni {
+#include <atomic>
+#include <utility>
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class LocalObject;
+namespace jni {
 
-template <typename TUndecayed>
-struct ProxyHelper;
+template <const auto& jvm_v_ = kDefaultJvm>
+class JvmRef;
 
-// Proxy is a metafunction that gives useful conversions from
-// types and forwards to a corresponding type that's viable as input.
-//
-// Note, given the context, different types present differently.  E.g. a |jint|
-// is always a jint, but a |jobject| is declared as a |jni::Class|, passed as a
-// |jni::RefBase&| and then converted to a |jobject| to cross the C API.
-//
-// |Proxy_t| will select the correct proxy for any of the above types.  To be
-// specific, |Proxy_t| of any type in |Arg| or |AsDecl| will return
-// the parent Proxy.
-//
-// Each proxy exports aliases for a given |CDecl|.
-//  |Index|: A uniquely identifying Key for proxy lookup.  This is usually the
-//    CDecl (e.g. jint => jint), but rich types may differ (Object =>jobject).
-//  |CDecl|: This is both the unique ID for a given proxy, as well as the
-//    distinct type (of which there is only one) that is usable when invoking a
-//    JNI call through the C API (e.g. |jint|, |jobject|).
-//  |AsArg|: All valid passable types.
-//  |AsDecl|: The type to be used in a function declaration, either as
-//   return or as a declared argument. If is templated by |class_v| and
-//   |class_loader_v| which can allow for additional decoration.
-template <typename CDecl, typename Enable>
-struct Proxy : public ProxyBase<CDecl> {};
+// Helper for JvmRef to enforce correct sequencing of getting and setting
+// process level static fo JavaVM*.
+class JvmRefBase {
+ protected:
+  friend class ThreadGuard;
+  friend class ThreadLocalGuardDestructor;
 
-template <typename VoidType>
-struct Proxy<VoidType,
-             typename std::enable_if_t<std::is_same_v<VoidType, void>>>
-    : public ProxyBase<void> {};
+  JvmRefBase(JavaVM* vm) { process_level_jvm_.store(vm); }
+  ~JvmRefBase() { process_level_jvm_.store(nullptr); }
 
-template <typename CharType>
-struct Proxy<CharType,
-             typename std::enable_if_t<std::is_same_v<CharType, jchar>>>
-    : public ProxyBase<jchar> {
-  using AsArg = std::tuple<char, jchar>;
-  using AsDecl = std::tuple<char, jchar>;
+  static JavaVM* GetJavaVm() { return process_level_jvm_.load(); }
+  static void SetJavaVm(JavaVM* jvm) { process_level_jvm_.store(jvm); }
 
-  template <typename OverloadSelection, typename T>
-  static constexpr bool kViable = IsConvertibleKey<T>::template value<char> ||
-                                  IsConvertibleKey<T>::template value<jchar>;
+  static inline std::atomic<JavaVM*> process_level_jvm_ = nullptr;
 };
 
-template <typename BooleanType>
-struct Proxy<BooleanType,
-             typename std::enable_if_t<std::is_same_v<BooleanType, jboolean>>>
-    : public ProxyBase<jboolean> {
-  using AsArg = std::tuple<jboolean, bool>;
-  using AsDecl = std::tuple<jboolean, bool>;
+// Designed to be the very last JniBind object to execute on the thread.
+// Objects passed by move for lambdas will be destructed after any contents
+// statements within their lambda, and `ThreadGuard` can't be moved into the
+// lambda because its construction will be on the host thread. This static
+// teardown guarantees a delayed destruction beyond any GlobalObject.
+class ThreadLocalGuardDestructor {
+ public:
+  bool detach_thread_when_all_guards_released_ = false;
 
-  template <typename OverloadSelection, typename T>
-  static constexpr bool kViable =
-      IsConvertibleKey<T>::template value<jboolean> ||
-      IsConvertibleKey<T>::template value<bool>;
+  // By calling this the compiler is obligated to perform initalisation.
+  void ForceDestructionOnThreadClose() {}
+
+  ~ThreadLocalGuardDestructor() {
+    if (detach_thread_when_all_guards_released_) {
+      JavaVM* jvm = JvmRefBase::GetJavaVm();
+      if (jvm) {
+        jvm->DetachCurrentThread();
+      }
+    }
+  }
 };
 
-template <typename LongType>
-struct Proxy<LongType,
-             typename std::enable_if_t<std::is_same_v<LongType, jlong>>>
-    : public ProxyBase<jlong> {
-  using AsArg = std::tuple<long, jlong>;
-  using AsDecl = std::tuple<long, jlong>;
+// ThreadGuard attaches and detaches JNIEnv* objects on the creation of new
+// threads.  All new threads which want to use JNI Wrapper must hold a
+// ThreadGuard beyond the scope of all created objects.  If the ThreadGuard
+// needs to create an Env, it will also detach itself.
+class ThreadGuard {
+ public:
+  ~ThreadGuard() {
+    thread_guard_count_--;
+  }
 
-  template <typename OverloadSelection, typename T>
-  static constexpr bool kViable = IsConvertibleKey<T>::template value<long> ||
-                                  IsConvertibleKey<T>::template value<jlong>;
+  ThreadGuard(ThreadGuard&) = delete;
+  ThreadGuard(ThreadGuard&&) = delete;
 
-  static jlong ProxyAsArg(jlong val) { return val; }
+  template <const auto& jvm_v_>
+  friend class JvmRef;
 
-  // jlong is a smaller type on ARM than x86.
-  // When jlong is not equivalent, we upcast to the wider type.
-  template <typename T,
-            typename = std::enable_if_t<std::is_same_v<T, long> &&
-                                        !std::is_same_v<jlong, long>>>
-  static jlong ProxyAsArg(T val) {
-    return jlong{val};
+  // This constructor must *never* be called before a |JvmRef| has been
+  // constructed. It depends on static setup from |JvmRef|.
+  [[nodiscard]] ThreadGuard() {
+    thread_local_guard_destructor.ForceDestructionOnThreadClose();
+
+    // Nested ThreadGuards should be permitted in the same way mutex locks are.
+    thread_guard_count_++;
+    if (thread_guard_count_ != 1) {
+      // SetEnv has been called prior, GetEnv is currently valid.
+      return;
+    }
+
+    // Declarations for AttachCurrentThread are inconsistent across different
+    // JNI headers.  This forces a cast to whatever the expected type is.
+    JavaVM* const vm = JvmRefBase::GetJavaVm();
+    JNIEnv* jni_env = 0;
+
+    using TypeForGetEnv =
+        metaprogramming::FunctionTraitsArg_t<decltype(&JavaVM::GetEnv), 1>;
+    const int code =
+        vm->GetEnv(reinterpret_cast<TypeForGetEnv>(&jni_env), JNI_VERSION_1_6);
+
+    if (code != JNI_OK) {
+      using TypeForAttachment = metaprogramming::FunctionTraitsArg_t<
+          decltype(&JavaVM::AttachCurrentThread), 1>;
+      vm->AttachCurrentThread(reinterpret_cast<TypeForAttachment>(&jni_env),
+                              nullptr);
+      thread_local_guard_destructor.detach_thread_when_all_guards_released_ =
+          true;
+    }
+    // Why not store this locally to ThreadGuard?
+    //
+    // JNIEnv is thread local static, and the context an object is built from
+    // may not have easy access to a JNIEnv* (or this ThreadGuard).  For most
+    // constructions of new objects, the env is likely trivial (it's passed as
+    // part of the JNI call), however, if an object reference is moved from one
+    // thread to another, the JNIEnv* is certainly not available.
+    JniEnv::SetEnv(jni_env);
   }
-};
 
-////////////////////////////////////////////////////////////////////////////////
-// Object Proxy Definitions.
-////////////////////////////////////////////////////////////////////////////////
-template <typename JObject>
-struct Proxy<JObject,
-             typename std::enable_if_t<std::is_same_v<JObject, jobject>>>
-    : public ProxyBase<jobject> {
-  using AsDecl = std::tuple<Object>;
-  using AsArg = std::tuple<jobject, RefBaseTag<jobject>, LoaderTag>;
+ private:
+  static inline thread_local int thread_guard_count_ = 0;
+  static inline thread_local ThreadLocalGuardDestructor
+      thread_local_guard_destructor{};
+};
 
-  template <typename InputParamSelectionT, typename T>
-  struct ContextualViabilityHelper {
-    // TODO(b/143908983): This is overly permissive, see method_selection_test.
-    static constexpr bool kViable = std::is_same_v<T, jobject>;
-  };
+// Represents a runtime instance of a Java Virtual Machine.
+// The caller is responsible for dropping this object from scope when
+// JNI_OnUnload is called.
+//
+// For any new thread spawned, a ThreadGuard must be held.  The caller is
+// responsible for ensuring all ThreadGuards fall from scope before JvmRef falls
+// from scope.
+//
+// The caller is also responsible for thread safety of all objects that have
+// been built during the lifetime of the JVM.  i.e If any objects have been
+// built, they must fall from scope prior to JvmRef falling from scope.
+//
+// There should only be one instance of JvmRef created at a time. If the
+// lifetimes of multiple JvmRef overlap, then one instance may get an invalid
+// JavaVM after the first instance is destroyed.
+template <const auto& jvm_v_>
+class JvmRef : public JvmRefBase {
+ public:
+  template <size_t ClassLoaderIdx>
+  struct TeardownClassesHelper {
+    template <size_t... Is>
+    static constexpr void TeardownClass(
+        std::index_sequence<Is...> index_sequence) {
+      (ClassRef_t<JniT<jobject, kNoClassSpecified, kDefaultClassLoader, jvm_v_,
+                       0, Is, ClassLoaderIdx>
 
-  template <typename IdT,
-            template <const auto&, const auto&, const auto&> class Container,
-            const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-  struct ContextualViabilityHelper<IdT,
-                                   Container<class_v, class_loader_v, jvm_v>> {
-    // TODO(b/174272629): Exclude objects loaded by invalid loaders.
-    static constexpr bool kViable =
-        std::string_view{class_v.name_} == std::string_view{IdT::Val().name_};
+                  >::MaybeReleaseClassRef(),
+       ...);
+    }
   };
 
-  template <typename IdT, typename T>
-  static constexpr bool kViable = ContextualViabilityHelper<IdT, T>::kViable;
-
-  template <typename Id>
-  struct Helper {
-    static constexpr auto kClass{Id::Val()};
-    static constexpr auto kClassLoader{Id::JniT::GetClassLoader()};
+  template <size_t... Is>
+  constexpr void TeardownClassloadersHelper(
+      std::index_sequence<Is...> index_sequence) {
+    (TeardownClassesHelper<Is>::TeardownClass(
+         std::make_index_sequence<
+             std::tuple_size_v<decltype(std::get<Is>(jvm_v_.class_loaders_)
+                                            .supported_classes_)>>()),
+     ...);
+  }
 
-    // TODO(b/174272629): Class loaders should also be enforced.
-    using type = LocalObject<kClass, kClassLoader, kDefaultJvm>;
-  };
+  JavaVM* BuildJavaVMFromEnv(JNIEnv* env) {
+    JavaVM* vm = nullptr;
+    // 0 Is success.
+    if (env->GetJavaVM(&vm) == 0) {
+      return vm;
+    } else {
+      return nullptr;
+    }
+  }
 
-  template <typename Id>
-  using AsReturn = typename Helper<Id>::type;
+  explicit JvmRef(JNIEnv* env) : JvmRefBase(BuildJavaVMFromEnv(env)) {}
+  explicit JvmRef(JavaVM* vm) : JvmRefBase(vm) {}
 
-  static jobject ProxyAsArg(jobject obj) { return obj; };
+  ~JvmRef() {
+    TeardownClassloadersHelper(
+        std::make_index_sequence<
+            std::tuple_size_v<decltype(jvm_v_.class_loaders_)>>());
 
-  // Applies for both local and global.
-  template <typename T>
-  static jobject ProxyAsArg(T& t) {
-    return jobject{t};
-  };
+    // This object has two lifecycle phases in relation to data races
+    // 1)  Value is null, when it is guarded by the ClassRef mutex
+    //     (implicitly part of ClassRef's behaviour).
+    // 2)  JVM is tearing down.  At this point, the caller is responsible for
+    //     releasing all native resources.
+    //     ReleaseAllClassRefsForDefaultClassLoader will only ever be torn down
+    //     by JvmRef::~JvmRef, and JvmRef cannot be moved, therefore it is
+    //     guaranteed to be in a single threaded context.
+    auto& default_loaded_class_list = GetDefaultLoadedClassList();
+    for (metaprogramming::DoubleLockedValue<jclass>* maybe_loaded_class_id :
+         default_loaded_class_list) {
+      maybe_loaded_class_id->Reset([](jclass clazz) {
+        LifecycleHelper<jobject, LifecycleType::GLOBAL>::Delete(clazz);
+      });
+    }
+    default_loaded_class_list.clear();
 
-  // Applies for both local and global.
-  template <typename T>
-  static jobject ProxyAsArg(T&& t) {
-    return t.Release();
-  };
-};
+    // Methods do not need to be released, just forgotten.
+    auto& default_loaded_method_ref_list = GetDefaultLoadedMethodList();
+    for (metaprogramming::DoubleLockedValue<jmethodID>* cached_method_id :
+         default_loaded_method_ref_list) {
+      cached_method_id->Reset();
+    }
+    default_loaded_method_ref_list.clear();
 
-}  // namespace jni
+    // Fields do not need to be released, just forgotten.
+    auto& default_loaded_field_ref_list = GetDefaultLoadedFieldList();
+    for (metaprogramming::DoubleLockedValue<jfieldID>* cached_field_id :
+         default_loaded_field_ref_list) {
+      cached_field_id->Reset();
+    }
+    default_loaded_field_ref_list.clear();
+  }
 
+  // Deleted in order to make various threading guarantees (see class_ref.h).
+  JvmRef(const JvmRef&) = delete;
+  JvmRef(JvmRef&&) = delete;
 
-namespace jni {
+  // All new threads MUST create a guard by calling |BuildThreadGuard|.
+  // If a JNIEnv does not exist, this will DetachCurrentThread when done.
+  [[nodiscard]] ThreadGuard BuildThreadGuard() const { return {}; }
 
-template <typename JniT, size_t field_idx_>
-struct FieldSelection {
-  using IdT = Id<JniT, IdType::FIELD, field_idx_>;
-  static constexpr IdType kRetTypeId = IdType::FIELD;
+ private:
+  // Main thread has a JNIEnv just like every other thread.
+  const ThreadGuard thread_guard_ = {};
 };
 
+JvmRef(JNIEnv*) -> JvmRef<kDefaultJvm>;
+JvmRef(JavaVM*) -> JvmRef<kDefaultJvm>;
+
 }  // namespace jni
 
-#include <cstddef>
-#include <tuple>
 #include <type_traits>
 
 namespace jni::metaprogramming {
 
-// "Unfurls" an index sequence onto a container, and provides convenience
-// helpers
-//
-// |type| is a variadic metafunction that generates a tuple for each type
-//  where each type is Container<Idx, Ts...> for [0, Is...).
-//    i.e. std::tuple<Container<0, Ts...>, Container<1, Ts...>, ...>
-//
-// |val| is a variadic data member that is the fold of the val member of each
-//   element of |type|. If |use_conjunction_fold_on_val| is true, the fold
-//   operator will be &&, otherwise it will be ||.
-template <template <std::size_t, typename...> class Container, std::size_t Is,
-          bool use_conjunction_fold_on_val = true>
-struct Unfurl {
-  template <typename Ts, typename Indexes>
-  struct Helper;
-
-  template <typename... Ts, std::size_t... Indices>
-  struct Helper<std::tuple<Ts...>, std::index_sequence<Indices...>> {
-    using type = std::tuple<Container<Indices, Ts...>...>;
-
-    static constexpr bool val = use_conjunction_fold_on_val
-                                    ? (Container<Indices, Ts...>::val && ...)
-                                    : (Container<Indices, Ts...>::val || ...);
-  };
-
-  template <typename... Ts>
-  using type =
-      typename Helper<std::tuple<Ts...>, std::make_index_sequence<Is>>::type;
-
-  template <typename... Ts>
-  static constexpr bool val =
-      Helper<std::tuple<Ts...>, std::make_index_sequence<Is>>::val;
-};
-
-template <std::size_t Is, template <std::size_t, typename...> class Container,
-          typename... Ts>
-using Unfurl_t = typename Unfurl<Container, Is>::template type<Ts...>;
-
-template <std::size_t Is, template <std::size_t, typename...> class Container,
-          typename... Ts>
-static constexpr bool UnfurlConjunction_v =
-    Unfurl<Container, Is, true>::template val<Ts...>;
-
-template <std::size_t Is, template <std::size_t, typename...> class Container,
-          typename... Ts>
-static constexpr bool UnfurlDisjunction_v =
-    Unfurl<Container, Is, false>::template val<Ts...>;
+template <typename T1>
+struct DeepEqual;
 
-}  // namespace jni::metaprogramming
+template <typename T1, typename T2>
+static constexpr bool DeepEqual_v = DeepEqual<T1>::template val<T2>;
 
-namespace jni::metaprogramming {
+template <typename Container1>
+struct TypesEqual;
 
-struct Max {
-  template <typename T1, typename T2>
+template <typename Container1_>
+struct TypesEqual {
+  template <typename Container1, typename Container2>
   struct Helper;
 
-  template <const auto v1, const auto v2>
-  struct Helper<Val<v1>, Val<v2>> {
-    using type = std::conditional_t<(v1 > v2), Val<v1>, Val<v2>>;
-  };
+  template <template <typename...> class Container1,
+            template <typename...> class Container2, typename... T1s,
+            typename... T2s>
+  struct Helper<Container1<T1s...>, Container2<T2s...>> {
+    static constexpr bool Val() {
+      if constexpr (sizeof...(T1s) == sizeof...(T2s)) {
+        // Containers are interchangeable (i.e. the same).
+        if constexpr (std::is_same_v<Container1<T1s...>, Container2<T1s...>>) {
+          return (DeepEqual_v<T1s, T2s> && ...);
+        } else {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
 
-  template <typename T1, typename T2>
-  using type = typename Helper<T1, T2>::type;
-};
+    static constexpr bool val = Val();
+  };
 
-template <typename T1, typename T2>
-using Max_t = typename Max::type<T1, T2>;
+  template <typename Container2>
+  static constexpr bool val = Helper<Container1_, Container2>::val;
+};
+
+template <typename T1>
+struct DeepEqual {
+  template <PackType pack_type_1, PackType pack_type_2>
+  static constexpr bool Compatible() {
+    if constexpr (pack_type_1 == PackType::NOT_CONTAINER ||
+                  pack_type_2 == PackType::NOT_CONTAINER) {
+      // Non-containers only with non-containers.
+      return pack_type_1 == PackType::NOT_CONTAINER &&
+             pack_type_2 == PackType::NOT_CONTAINER;
+    } else if constexpr (pack_type_1 == PackType::TYPES ||
+                         pack_type_2 == PackType::TYPES) {
+      // Type packs only with other type packs.
+      return pack_type_1 == PackType::TYPES && pack_type_2 == PackType::TYPES;
+    } else {
+      // All the auto pack types.
+      return true;
+    }
+  }
 
-template <typename T1, typename T2>
-static constexpr auto Max_v = Max_t<T1, T2>::val;
+  template <typename T2>
+  static constexpr bool Val() {
+    const PackType pack_type_1 = PackDiscriminator_e<T1>;
+    const PackType pack_type_2 = PackDiscriminator_e<T2>;
 
-struct Min {
-  template <typename T1, typename T2>
-  struct Helper;
+    if constexpr (!Compatible<pack_type_1, pack_type_2>()) {
+      return false;
+    } else if constexpr (PackDiscriminator_e<T1> == PackType::NOT_CONTAINER) {
+      return std::is_same_v<T1, T2>;
+    } else if constexpr (PackDiscriminator_e<T1> == PackType::TYPES) {
+      return TypesEqual<T1>::template val<T2>;
+    } else {
+      return ValsEqual_v<T1, T2>;
+    }
 
-  template <const auto v1, const auto v2>
-  struct Helper<Val<v1>, Val<v2>> {
-    using type = std::conditional_t<(v1 < v2), Val<v1>, Val<v2>>;
-  };
+    return true;
+  }
 
-  template <typename T1, typename T2>
-  using type = typename Helper<T1, T2>::type;
+  template <typename T2>
+  static constexpr bool val = Val<T2>();
 };
 
-template <typename T1, typename T2>
-using Min_t = typename Min::type<T1, T2>;
-
-template <typename T1, typename T2>
-static constexpr auto Min_v = Min_t<T1, T2>::val;
-
 }  // namespace jni::metaprogramming
 
-#include <tuple>
+#include <optional>
+#include <string>
 #include <type_traits>
+#include <utility>
 
-namespace jni::metaprogramming {
+namespace jni {
 
-// Metafunction for querying traits return and argument types of a function.
-template <typename>
-struct FunctionTraits;
+// Represents a runtime instance of a JNI Object.  Instead of using this class
+// directly, instead the more specialised types such as LocalObject,
+// GlobalObject, etc.
+//
+// To call methods on the object, use the  operator(), to access fields, use
+// operator[].
+template <typename JniT>
+class ObjectRef
+    : public metaprogramming::InvocableMap<
+          ObjectRef<JniT>, JniT::stripped_class_v, typename JniT::ClassT,
+          &JniT::ClassT::methods_>,
+      public metaprogramming::QueryableMap_t<
+          ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::fields_>,
+      public RefBase<JniT> {
+ protected:
+  static_assert(
+      JniT::class_loader_v
+          .template SupportedDirectlyOrIndirectly<JniT::class_v>(),
+      "This class is not directly or indirectly supported by this loader.");
+  static_assert(!metaprogramming::StringContains_v<JniT::kName, '.'>,
+                "Use '/', not '.' in class names (for maximum) portability.");
+
+  using RefBase = RefBase<JniT>;
+
+  ObjectRef() = delete;
+  ObjectRef& operator=(const ObjectRef& rhs) = delete;
+
+  jclass GetJClass() const {
+    return ClassRef_t<JniT>::GetAndMaybeLoadClassRef(RefBase::object_ref_);
+  }
 
-// Partial specialisation for functions.
-template <typename Return_, typename... Args>
-struct FunctionTraits<Return_(Args...)> {
-  using Return = Return_;
-  using ArgsTup = std::tuple<Args...>;
+ public:
+  explicit ObjectRef(RefBaseTag<typename JniT::StorageType>&& rhs)
+      : RefBase(std::move(rhs)) {}
 
-  static constexpr std::size_t arity = sizeof...(Args);
+  // Invoked through CRTP from InvocableMap.
+  template <size_t I, typename... Args>
+  auto InvocableMapCall(const char* key, Args&&... args) const {
+    using IdT = Id<JniT, IdType::OVERLOAD_SET, I>;
+    using MethodSelectionForArgs =
+        OverloadSelector<IdT, IdType::OVERLOAD, IdType::OVERLOAD_PARAM,
+                         Args...>;
 
-  template <std::size_t N>
-  struct Argument {
-    static_assert(N < arity, "Parameter index exceeds argument count.");
-    using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
-  };
-};
+    static_assert(MethodSelectionForArgs::kIsValidArgSet,
+                  "JNI Error: Invalid argument set.");
 
-// Partial specialisation for function pointer.
-template <typename R, typename... Args>
-struct FunctionTraits<R (*)(Args...)> : public FunctionTraits<R(Args...)> {};
+    return MethodSelectionForArgs::OverloadRef::Invoke(
+        GetJClass(), RefBase::object_ref_, std::forward<Args>(args)...);
+  }
 
-// Member function pointer
-template <class C, class R, class... Args>
-struct FunctionTraits<R (C::*)(Args...)>
-    : public FunctionTraits<R(C&, Args...)> {};
+  // Invoked through CRTP from QueryableMap.
+  template <size_t I>
+  auto QueryableMapCall(const char* key) const {
+    return FieldRef<JniT, IdType::FIELD, I>{GetJClass(), RefBase::object_ref_};
+  }
+};
 
-// const member function pointer
-template <class C, class R, class... Args>
-struct FunctionTraits<R (C::*)(Args...) const>
-    : public FunctionTraits<R(C&, Args...)> {};
+// Imbues constructors for ObjectRefs and handles calling the correct
+// intermediate constructors.  Access to this class is constrainted for non
+// default classloaders (see |ValidatorProxy|).
+template <typename JniT>
+class ConstructorValidator : public ObjectRef<JniT> {
+ public:
+  using Base = ObjectRef<JniT>;
+  using Base::Base;
 
-// Member object pointer
-template <class C, class R>
-struct FunctionTraits<R(C::*)> : public FunctionTraits<R(C&)> {};
+  // Objects can still be wrapped.  This could happen if a classloaded object
+  // is built in Java and then passed through to JNI.
+  ConstructorValidator(typename JniT::StorageType obj) : Base(obj) {}
 
-template <typename T>
-using FunctionTraitsReturn_t = typename FunctionTraits<T>::Return;
+  template <LifecycleType, const auto& jvm_v, const auto& class_loader_v>
+  friend class ClassLoaderRef;
 
-template <typename T, std::size_t argument_idx>
-using FunctionTraitsArg_t =
-    typename FunctionTraits<T>::template Argument<argument_idx>::type;
+  static constexpr std::size_t kNumConstructors =
+      std::tuple_size_v<decltype(JniT::class_v.constructors_)>;
 
-}  // namespace jni::metaprogramming
+  template <typename... Args>
+  struct Helper {
+    using IdT = Id<JniT, IdType::OVERLOAD_SET, kNoIdx>;
 
-#include <tuple>
+    // 0 is (always) used to represent the constructor.
+    using type = OverloadSelector<IdT, IdType::OVERLOAD, IdType::OVERLOAD_PARAM,
+                                  Args...>;
+  };
 
-namespace jni::metaprogramming {
+  template <typename... Args>
+  using Permutation_t = typename Helper<Args...>::type;
 
-// Call takes a tuple of arguments and returns a tuple of elements
-// dereferenced once (with no arguments). Eventually, this should have
-// the pack discriminated forwarding (to optionally pass args).
-struct Call {
-  template <typename T>
-  struct Helper;
+  template <typename... Args,
+            typename std::enable_if<(sizeof...(Args) != 0 && JniT::kRank == 0),
+                                    int>::type = 0>
+  ConstructorValidator(Args&&... args)
+      : Base(static_cast<typename JniT::StorageType>(
+            Permutation_t<Args...>::OverloadRef::Invoke(
+                Base::GetJClass(), Base::object_ref_,
+                std::forward<Args>(args)...)
+                .Release())) {
+    static_assert(Permutation_t<Args...>::kIsValidArgSet,
+                  "You have passed invalid arguments to construct this type.");
+  }
 
-  template <typename... Ts>
-  struct Helper<std::tuple<Ts...>> {
-    using type = std::tuple<typename Ts::type...>;
-  };
+  ConstructorValidator()
+      : Base(Permutation_t<>::OverloadRef::Invoke(Base::GetJClass(),
+                                                  Base::object_ref_)
+                 .Release()) {}
+};
 
-  template <typename T>
-  using type = typename Helper<T>::type;
+// Forward declaration for constructor validator (ctor augmentations).
+template <typename JniT>
+struct ValidatorProxy : public ConstructorValidator<JniT> {
+  using Base = ConstructorValidator<JniT>;
+  using Base::Base;
 };
 
-template <typename T>
-using Call_t = typename Call::type<T>;
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+using ObjectRefBuilder_t =
+    ValidatorProxy<JniT<jobject, class_v_, class_loader_v_, jvm_v_>>;
 
-}  // namespace jni::metaprogramming
+}  // namespace jni
 
-#include <mutex>
-#include <tuple>
-#include <utility>
+#include <type_traits>
 
 namespace jni {
 
-// See JvmRef::~JvmRef.
-static inline auto& GetDefaultLoadedMethodList() {
-  static auto* ret_val =
-      new std::vector<metaprogramming::DoubleLockedValue<jmethodID>*>{};
-  return *ret_val;
-}
-
-template <typename IdT_, IdType kReturnIDType>
-struct OverloadRef {
-  using IdT = IdT_;
-  using ReturnIdT = typename IdT::template ChangeIdType<kReturnIDType>;
-  using ReturnProxied =
-      Return_t<typename ReturnIdT::MaterializeCDeclT, ReturnIdT>;
-
-  static jmethodID GetMethodID(jclass clazz) {
-    static jni::metaprogramming::DoubleLockedValue<jmethodID> return_value;
+// Convenience struct for returning results from pinning array.
+template <typename SpanType>
+struct GetArrayElementsResult {
+  SpanType* ptr_;
+  jboolean is_copy;
+};
 
-    return return_value.LoadAndMaybeInit([=]() {
-      if constexpr (IdT_::JniT::GetClassLoader() == kDefaultClassLoader) {
-        GetDefaultLoadedMethodList().push_back(&return_value);
-      }
+struct JniArrayHelperBase {
+  static inline std::size_t GetLength(jarray array) {
+    return jni::JniEnv::GetEnv()->GetArrayLength(array);
+  }
+};
 
-      if constexpr (IdT::kIsStatic) {
-        return jni::JniHelper::GetStaticMethodID(clazz, IdT::Name(),
-                                                 Signature_v<IdT>.data());
-      } else {
-        return jni::JniHelper::GetMethodID(clazz, IdT::Name(),
-                                           Signature_v<IdT>.data());
-      }
-    });
+// Rank 2+ arrays all behave like object arrays.
+template <typename SpannedType, std::size_t kRank>
+struct JniArrayHelper : public JniArrayHelperBase {
+  static inline jobjectArray NewArray(std::size_t size,
+                                      jclass class_id = nullptr,
+                                      jobject initial_element = nullptr) {
+    return jni::JniEnv::GetEnv()->NewObjectArray(size, class_id,
+                                                 initial_element);
   }
 
-  template <typename... Params>
-  static ReturnProxied Invoke(jclass clazz, jobject object,
-                              Params&&... params) {
-    constexpr std::size_t kRank = ReturnIdT::kRank;
-    constexpr bool kStatic = ReturnIdT::kIsStatic;
-    const jmethodID mthd = OverloadRef::GetMethodID(clazz);
+  // The API of fetching objects only permits accessing one object at a time.
+  static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
+    return jni::JniEnv::GetEnv()->GetObjectArrayElement(array, idx);
+  };
 
-    if constexpr (std::is_same_v<ReturnProxied, void>) {
-      return InvokeHelper<void, kRank, kStatic>::Invoke(
-          object, clazz, mthd,
-          Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...);
-    } else if constexpr (IdT::kIsConstructor) {
-      return ReturnProxied{
-          LifecycleHelper<jobject, LifecycleType::LOCAL>::Construct(
-              clazz, mthd,
-              Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...)};
-    } else {
-      return static_cast<ReturnProxied>(
-          InvokeHelper<typename ReturnIdT::CDecl, kRank, kStatic>::Invoke(
-              object, clazz, mthd,
-              Proxy_t<Params>::ProxyAsArg(std::forward<Params>(params))...));
-    }
-  }
+  // The API of fetching objects only permits accessing one object at a time.
+  static inline void SetArrayElement(jobjectArray array, std::size_t idx,
+                                     SpannedType obj) {
+    jni::JniEnv::GetEnv()->SetObjectArrayElement(array, idx, obj);
+  };
 };
 
-}  // namespace jni
+template <>
+struct JniArrayHelper<jboolean, 1> : public JniArrayHelperBase {
+  using AsArrayType = jbooleanArray;
 
+  static inline jbooleanArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewBooleanArray(size);
+  }
 
-#include <mutex>
-#include <string_view>
-#include <tuple>
-#include <utility>
+  static inline GetArrayElementsResult<jboolean> GetArrayElements(
+      jarray array) {
+    GetArrayElementsResult<jboolean> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetBooleanArrayElements(
+        static_cast<jbooleanArray>(array), &return_value.is_copy);
+    return return_value;
+  }
 
-namespace jni {
+  static inline void ReleaseArrayElements(jarray array, jboolean* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseBooleanArrayElements(
+        static_cast<jbooleanArray>(array), native_ptr, copy_back_mode);
+  }
+};
 
-// See JvmRef::~JvmRef.
-static inline auto& GetDefaultLoadedFieldList() {
-  static auto* ret_val =
-      new std::vector<metaprogramming::DoubleLockedValue<jfieldID>*>{};
-  return *ret_val;
-}
+template <>
+struct JniArrayHelper<jbyte, 1> : public JniArrayHelperBase {
+  using AsArrayType = jbyteArray;
 
-// Represents a live instance of Field I's definition.
-//
-// Note, this class performs no cleanup on destruction.  jFieldIDs are static
-// throughout the duration of a JVM's life, see JvmRef for teardown.
-template <typename JniT, IdType field_type, std::size_t I>
-class FieldRef {
- public:
-  using IdT = Id<JniT, field_type, I>;
-  using FieldSelectionT = FieldSelection<JniT, I>;
+  static inline jbyteArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewByteArray(size);
+  }
 
-  explicit FieldRef(jclass class_ref, jobject object_ref)
-      : class_ref_(class_ref), object_ref_(object_ref) {}
+  static inline GetArrayElementsResult<jbyte> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jbyte> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetByteArrayElements(
+        static_cast<jbyteArray>(array), &return_value.is_copy);
+    return return_value;
+  }
+
+  static inline void ReleaseArrayElements(jarray array, jbyte* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseByteArrayElements(
+        static_cast<jbyteArray>(array), native_ptr, copy_back_mode);
+  }
+};
 
-  FieldRef(const FieldRef&) = delete;
-  FieldRef(const FieldRef&&) = delete;
-  void operator=(const FieldRef&) = delete;
+template <>
+struct JniArrayHelper<jchar, 1> : public JniArrayHelperBase {
+  using AsArrayType = jcharArray;
 
-  // This method is thread safe.
-  static jfieldID GetFieldID(jclass clazz) {
-    static jni::metaprogramming::DoubleLockedValue<jfieldID> return_value;
+  static inline jcharArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewCharArray(size);
+  }
 
-    return return_value.LoadAndMaybeInit([=]() {
-      if constexpr (JniT::class_loader_v == kDefaultClassLoader) {
-        GetDefaultLoadedFieldList().push_back(&return_value);
-      }
+  static inline GetArrayElementsResult<jchar> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jchar> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetCharArrayElements(
+        static_cast<jcharArray>(array), &return_value.is_copy);
+    return return_value;
+  }
 
-      if constexpr (IdT::kIsStatic) {
-        return jni::JniHelper::GetStaticFieldID(clazz, IdT::Name(),
-                                                Signature_v<IdT>.data());
-      } else {
-        return jni::JniHelper::GetFieldID(clazz, IdT::Name(),
-                                          Signature_v<IdT>.data());
-      }
-    });
+  static inline void ReleaseArrayElements(jarray array, jchar* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseCharArrayElements(
+        static_cast<jcharArray>(array), native_ptr, copy_back_mode);
   }
+};
 
-  using ReturnProxied = Return_t<typename IdT::MaterializeCDeclT, IdT>;
+template <>
+struct JniArrayHelper<jshort, 1> : public JniArrayHelperBase {
+  using AsArrayType = jshortArray;
 
-  const auto& SelfVal() {
-    if constexpr (IdT::kIsStatic) {
-      return class_ref_;
-    } else {
-      return object_ref_;
-    }
+  static inline jshortArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewShortArray(size);
   }
 
-  ReturnProxied Get() {
-    return {FieldHelper<CDecl_t<typename IdT::RawValT>, IdT::kRank,
-                        IdT::kIsStatic>::GetValue(SelfVal(),
-                                                  GetFieldID(class_ref_))};
+  static inline GetArrayElementsResult<jshort> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jshort> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetShortArrayElements(
+        static_cast<jshortArray>(array), &return_value.is_copy);
+    return return_value;
   }
 
-  template <typename T>
-  void Set(T&& value) {
-    FieldHelper<CDecl_t<typename IdT::RawValT>, IdT::kRank,
-                IdT::kIsStatic>::SetValue(SelfVal(), GetFieldID(class_ref_),
-                                          Proxy_t<T>::ProxyAsArg(
-                                              std::forward<T>(value)));
+  static inline void ReleaseArrayElements(jarray array, jshort* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseShortArrayElements(
+        static_cast<jshortArray>(array), native_ptr, copy_back_mode);
   }
-
- private:
-  const jclass class_ref_;
-  const jobject object_ref_;
 };
 
-}  // namespace jni
-
-namespace jni::metaprogramming {
+template <>
+struct JniArrayHelper<jint, 1> : public JniArrayHelperBase {
+  using AsArrayType = jintArray;
 
-template <char sought>
-struct StringContains {
-  template <const std::string_view& str, typename IndexSequence>
-  struct Helper;
+  static inline jintArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewIntArray(size);
+  }
 
-  template <const std::string_view& str, std::size_t... Is>
-  struct Helper<str, std::index_sequence<Is...>> {
-    static constexpr bool val = ((str[Is] == sought) || ...);
-  };
+  static inline GetArrayElementsResult<jint> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jint> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetIntArrayElements(
+        static_cast<jintArray>(array), &return_value.is_copy);
+    return return_value;
+  }
 
-  template <const std::string_view& str>
-  static constexpr bool val =
-      Helper<str, std::make_index_sequence<str.length()>>::val;
+  static inline void ReleaseArrayElements(jarray array, int* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseIntArrayElements(
+        static_cast<jintArray>(array), native_ptr, copy_back_mode);
+  }
 };
 
-template <const std::string_view& str, char sought>
-static constexpr bool StringContains_v =
-    StringContains<sought>::template val<str>;
+template <>
+struct JniArrayHelper<jlong, 1> : public JniArrayHelperBase {
+  using AsArrayType = jlongArray;
 
-}  // namespace jni::metaprogramming
+  static inline jlongArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewLongArray(size);
+  }
 
-#include <limits>
-#include <type_traits>
-#include <utility>
+  static inline GetArrayElementsResult<jlong> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jlong> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetLongArrayElements(
+        static_cast<jlongArray>(array), &return_value.is_copy);
+    return return_value;
+  }
 
-namespace jni {
+  static inline void ReleaseArrayElements(jarray array, jlong* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseLongArrayElements(
+        static_cast<jlongArray>(array), native_ptr, copy_back_mode);
+  }
+};
 
-// Viablility helper for an exact parameter.
-template <std::size_t I, typename IdT, typename ValkReturnIDType,
-          typename... Ts>
-struct Viable {
-  static constexpr IdType kReturnIDType = ValkReturnIDType::val;
-  using IdTmp = typename IdT::template ChangeIdType<kReturnIDType>;
-  using IdTParamType = typename IdTmp::template ChangeIdx<2, I>;
+template <>
+struct JniArrayHelper<jfloat, 1> : public JniArrayHelperBase {
+  using AsArrayType = jfloatArray;
 
-  static constexpr bool val =
-      Proxy_t<typename IdTParamType::UnstrippedRawVal>::template kViable<
-          IdTParamType,
-          metaprogramming::TypeOfNthElement_t<I, std::decay_t<Ts>...>>;
-};
+  static inline jfloatArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewFloatArray(size);
+  }
 
-template <typename OverloadId, IdType kReturnIDType>
-struct ArgumentValidate {
-  // Helper to prevents instantiating mismatching size unrolls.
-  template <typename... Ts>
-  static constexpr bool ViableHelper() {
-    if constexpr (sizeof...(Ts) == OverloadId::kNumParams) {
-      return metaprogramming::UnfurlConjunction_v<
-          OverloadId::kNumParams, Viable, OverloadId,
-          metaprogramming::Val_t<kReturnIDType>, Ts...>;
-    } else {
-      return false;
-    }
+  static inline GetArrayElementsResult<jfloat> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jfloat> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetFloatArrayElements(
+        static_cast<jfloatArray>(array), &return_value.is_copy);
+    return return_value;
   }
 
-  template <typename... Ts>
-  static constexpr bool kValid = ViableHelper<Ts...>();
+  static inline void ReleaseArrayElements(jarray array, jfloat* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseFloatArrayElements(
+        static_cast<jfloatArray>(array), native_ptr, copy_back_mode);
+  }
 };
 
-template <typename IdT_, IdType kReturnIDType>
-struct OverloadSelection {
-  using IdT = IdT_;
+template <>
+struct JniArrayHelper<jdouble, 1> : public JniArrayHelperBase {
+  using AsArrayType = jdoubleArray;
 
-  template <typename... Ts>
-  static constexpr bool OverloadViable() {
-    return ArgumentValidate<IdT, kReturnIDType>::template kValid<Ts...>;
+  static inline jdoubleArray NewArray(std::size_t size) {
+    return jni::JniEnv::GetEnv()->NewDoubleArray(size);
   }
 
-  template <typename... Ts>
-  static constexpr size_t OverloadIdxIfViable() {
-    return OverloadViable<Ts...>() ? IdT::kSecondaryIdx : kNoIdx;
+  static inline GetArrayElementsResult<jdouble> GetArrayElements(jarray array) {
+    GetArrayElementsResult<jdouble> return_value;
+    return_value.ptr_ = jni::JniEnv::GetEnv()->GetDoubleArrayElements(
+        static_cast<jdoubleArray>(array), &return_value.is_copy);
+    return return_value;
+  }
+
+  static inline void ReleaseArrayElements(jarray array, jdouble* native_ptr,
+                                          bool copy_on_completion) {
+    const jint copy_back_mode = copy_on_completion ? 0 : JNI_ABORT;
+    jni::JniEnv::GetEnv()->ReleaseDoubleArrayElements(
+        static_cast<jdoubleArray>(array), native_ptr, copy_back_mode);
   }
 };
 
-template <typename IdT_, IdType kIDType = IdType::OVERLOAD,
-          IdType kReturnIDType = IdType::OVERLOAD_PARAM>
-struct MethodSelection {
-  using IdT = IdT_;
-  using JniT = typename IdT::JniT;
+// Note, this requires both a jclass and a sample jobject to build from which
+// is unlike any other new array construction.
+template <std::size_t kRank>
+struct JniArrayHelper<jobject, kRank> : public JniArrayHelperBase {
+  static inline jobjectArray NewArray(std::size_t size, jclass class_id,
+                                      jobject initial_element) {
+    return jni::JniEnv::GetEnv()->NewObjectArray(size, class_id,
+                                                 initial_element);
+  }
 
-  template <std::size_t I, typename... Ts>
-  struct Helper {
-    using type = metaprogramming::Val_t<OverloadSelection<
-        Id<JniT, kIDType, IdT::kIdx, I>,
-        kReturnIDType>::template OverloadIdxIfViable<Ts...>()>;
+  // The API of fetching objects only permits accessing one object at a time.
+  static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
+    return jni::JniEnv::GetEnv()->GetObjectArrayElement(array, idx);
   };
 
-  template <typename... Ts>
-  static constexpr std::size_t kIdxForTs = metaprogramming::ReduceAsPack_t<
-      metaprogramming::Min, metaprogramming::Call_t<metaprogramming::Unfurl_t<
-                                IdT::NumParams(), Helper, Ts...>>>::val;
+  // The API of fetching objects only permits accessing one object at a time.
+  static inline void SetArrayElement(jobjectArray array, std::size_t idx,
+                                     jobject obj) {
+    jni::JniEnv::GetEnv()->SetObjectArrayElement(array, idx, obj);
+  };
+};
 
-  template <typename... Ts>
-  using FindOverloadSelection =
-      OverloadSelection<Id<JniT, kIDType, IdT::kIdx, kIdxForTs<Ts...>>,
-                        kReturnIDType>;
+}  // namespace jni
 
-  template <typename... Ts>
-  static constexpr bool ArgSetViable() {
-    return kIdxForTs<Ts...> != kNoIdx;
-  }
-};
+namespace jni {
 
-template <typename IdT, IdType kIDType, IdType kReturnIDType, typename... Args>
-struct OverloadSelector {
-  using OverloadSelectionForArgs = typename MethodSelection<
-      IdT, kIDType, kReturnIDType>::template FindOverloadSelection<Args...>;
+// Creates an additional reference to the underlying object.
+// When used for local, presumes local, for global, presumes global.
+struct CreateCopy {};
 
-  using OverloadRef =
-      OverloadRef<Id<typename IdT::JniT, kIDType, IdT::kIdx,
-                     OverloadSelectionForArgs::IdT::kSecondaryIdx>,
-                  kReturnIDType>;
+// This tag allows the constructor to promote underlying jobject for you.
+struct PromoteToGlobal {};
 
-  static constexpr bool kIsValidArgSet =
-      MethodSelection<IdT, kIDType,
-                      kReturnIDType>::template ArgSetViable<Args...>();
-};
+// CAUTION: This tag assume the underlying jobject has been pinned as a global.
+// This is atypical when solely using JNI Bind, use with caution.
+struct AdoptGlobal {};
 
-}  // namespace jni
+// Marks the end of `ScopeEntry` daisy chain.
+struct ScopedTerminalTag {};
 
+// Shared implementation common to all `Entry`.
+// template <typename Base, LifecycleType lifecycleType, typename JniT>
+template <typename Base, LifecycleType lifecycleType, typename JniT,
+          typename ViableSpan>
+struct EntryBase : public Base {
+  using Base::Base;
+  using Span = typename JniT::SpanType;
 
-#include <atomic>
-#include <utility>
+  // `RefBaseTag` move constructor for object of same span type.
+  template <typename T, typename = std::enable_if_t<
+                            ::jni::metaprogramming::DeepEqual_v<EntryBase, T> ||
+                            std::is_base_of_v<RefBaseTag<Span>, T>>>
+  EntryBase(T&& rhs) : Base(rhs.Release()) {}
 
-namespace jni {
+  // "Copy" constructor: Additional reference to object will be created.
+  EntryBase(CreateCopy, ViableSpan object)
+      : Base(static_cast<Span>(
+            LifecycleHelper<Span, lifecycleType>::NewReference(
+                static_cast<Span>(object)))) {}
+};
 
-template <const auto& jvm_v_ = kDefaultJvm>
-class JvmRef;
+// Local scoped entry augmentation.
+template <LifecycleType lifecycleType, typename JniT, typename ViableSpan,
+          typename... ViableSpans>
+struct Entry
+    : public EntryBase<Entry<LifecycleType::LOCAL, JniT, ViableSpans...>,
+                       LifecycleType::LOCAL, JniT, ViableSpan> {
+  using Base = EntryBase<Entry<LifecycleType::LOCAL, JniT, ViableSpans...>,
+                         LifecycleType::LOCAL, JniT, ViableSpan>;
+  using Base::Base;
 
-class ThreadGuard;
-struct ThreadLocalGuardDestructor;
+  // "Wrap" constructor: Object released at end of scope.
+  Entry(ViableSpan object)
+      : Base(static_cast<typename JniT::StorageType>(object)) {}
+};
 
-// Helper for JvmRef to enforce correct sequencing of getting and setting
-// process level static fo JavaVM*.
-class JvmRefBase {
- protected:
-  friend class ThreadGuard;
-  friend class ThreadLocalGuardDestructor;
+// Global scoped entry augmentation.
+template <typename JniT, typename ViableSpan, typename... ViableSpans>
+struct Entry<LifecycleType::GLOBAL, JniT, ViableSpan, ViableSpans...>
+    : public EntryBase<Entry<LifecycleType::GLOBAL, JniT, ViableSpans...>,
+                       LifecycleType::GLOBAL, JniT, ViableSpan> {
+  using Base = EntryBase<Entry<LifecycleType::GLOBAL, JniT, ViableSpans...>,
+                         LifecycleType::GLOBAL, JniT, ViableSpan>;
+  using Base::Base;
 
-  JvmRefBase(JavaVM* vm) { process_level_jvm_.store(vm); }
-  ~JvmRefBase() { process_level_jvm_.store(nullptr); }
+  // "Promote" constructor: Creates new global, frees |obj| (standard).
+  explicit Entry(PromoteToGlobal, ViableSpan obj)
+      : Base(LifecycleHelper<typename JniT::StorageType,
+                             LifecycleType::GLOBAL>::Promote(obj)) {}
 
-  static JavaVM* GetJavaVm() { return process_level_jvm_.load(); }
-  static void SetJavaVm(JavaVM* jvm) { process_level_jvm_.store(jvm); }
+  // "Adopts" a global (non-standard).
+  explicit Entry(AdoptGlobal, ViableSpan obj) : Base(obj) {}
 
-  static inline std::atomic<JavaVM*> process_level_jvm_ = nullptr;
+ protected:
+  // Causes failure for illegal "wrap" like construction.
+  explicit Entry(ViableSpan object)
+      : Base(reinterpret_cast<typename JniT::SpanType>(object)) {}
 };
 
-// Designed to be the very last JniBind object to execute on the thread.
-// Objects passed by move for lambdas will be destructed after any contents
-// statements within their lambda, and `ThreadGuard` can't be moved into the
-// lambda because its construction will be on the host thread. This static
-// teardown guarantees a delayed destruction beyond any GlobalObject.
-struct ThreadLocalGuardDestructor {
-  bool detach_thread_when_all_guards_released_ = false;
+// Terminal Entry (ends daisy chain).
+template <typename JniT>
+struct Entry<LifecycleType::LOCAL, JniT, ScopedTerminalTag>
+    : public ValidatorProxy<JniT> {
+  using Base = ValidatorProxy<JniT>;
+  using Base::Base;
+};
 
-  // By calling this the compiler is obligated to perform initalisation.
-  void ForceDestructionOnThreadClose() {}
+template <typename JniT>
+struct Entry<LifecycleType::GLOBAL, JniT, ScopedTerminalTag>
+    : public ValidatorProxy<JniT> {
+  using Base = ValidatorProxy<JniT>;
+  using Base::Base;
+};
 
-  ~ThreadLocalGuardDestructor() {
-    if (detach_thread_when_all_guards_released_) {
-      JavaVM* jvm = JvmRefBase::GetJavaVm();
-      if (jvm) {
-        jvm->DetachCurrentThread();
-      }
+// Local augmentation.
+template <LifecycleType lifecycleType, typename JniT, typename... ViableSpans>
+struct Scoped
+    : public Entry<lifecycleType, JniT, ViableSpans..., ScopedTerminalTag> {
+  using Base = Entry<lifecycleType, JniT, ViableSpans..., ScopedTerminalTag>;
+  using Base::Base;
+
+  ~Scoped() {
+    if (Base::object_ref_) {
+      LifecycleHelper<typename JniT::StorageType, lifecycleType>::Delete(
+          Base::object_ref_);
     }
   }
 };
 
-// ThreadGuard attaches and detaches JNIEnv* objects on the creation of new
-// threads.  All new threads which want to use JNI Wrapper must hold a
-// ThreadGuard beyond the scope of all created objects.  If the ThreadGuard
-// needs to create an Env, it will also detach itself.
-class ThreadGuard {
- public:
-  ~ThreadGuard() {
-    thread_guard_count_--;
-  }
-
-  ThreadGuard(ThreadGuard&) = delete;
-  ThreadGuard(ThreadGuard&&) = delete;
+template <LifecycleType lifecycleType, typename JniT, typename... ViableSpans>
+Scoped(Scoped<lifecycleType, JniT, ViableSpans...>)
+    -> Scoped<lifecycleType, JniT, ViableSpans...>;
 
-  template <const auto& jvm_v_>
-  friend class JvmRef;
+}  // namespace jni
 
-  // This constructor must *never* be called before a |JvmRef| has been
-  // constructed. It depends on static setup from |JvmRef|.
-  [[nodiscard]] ThreadGuard() {
-    thread_local_guard_destructor.ForceDestructionOnThreadClose();
+#include <optional>
+#include <string>
+#include <string_view>
 
-    // Nested ThreadGuards should be permitted in the same way mutex locks are.
-    thread_guard_count_++;
-    if (thread_guard_count_ != 1) {
-      // SetEnv has been called prior, GetEnv is currently valid.
-      return;
-    }
+namespace jni {
 
-    // Declarations for AttachCurrentThread are inconsistent across different
-    // JNI headers.  This forces a cast to whatever the expected type is.
-    JavaVM* const vm = JvmRefBase::GetJavaVm();
-    JNIEnv* jni_env = 0;
+template <typename CrtpBase>
+class StringRefBase
+    : public ConstructorValidator<
+          JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>> {
+ public:
+  using ValidT = ConstructorValidator<
+      JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>>;
+  using ValidT::ValidT;
 
-    using TypeForGetEnv =
-        metaprogramming::FunctionTraitsArg_t<decltype(&JavaVM::GetEnv), 1>;
-    const int code =
-        vm->GetEnv(reinterpret_cast<TypeForGetEnv>(&jni_env), JNI_VERSION_1_6);
+  StringRefBase(std::nullptr_t) : ValidT(jstring{nullptr}) {}
+  StringRefBase(jstring object) : ValidT(object) {}
 
-    if (code != JNI_OK) {
-      using TypeForAttachment = metaprogramming::FunctionTraitsArg_t<
-          decltype(&JavaVM::AttachCurrentThread), 1>;
-      vm->AttachCurrentThread(reinterpret_cast<TypeForAttachment>(&jni_env),
-                              nullptr);
-      thread_local_guard_destructor.detach_thread_when_all_guards_released_ =
-          true;
+  ~StringRefBase() {
+    if (object_ref_) {
+      static_cast<CrtpBase&>(*this).ClassSpecificDeleteObjectRef(object_ref_);
     }
-    // Why not store this locally to ThreadGuard?
-    //
-    // JNIEnv is thread local static, and the context an object is built from
-    // may not have easy access to a JNIEnv* (or this ThreadGuard).  For most
-    // constructions of new objects, the env is likely trivial (it's passed as
-    // part of the JNI call), however, if an object reference is moved from one
-    // thread to another, the JNIEnv* is certainly not available.
-    JniEnv::SetEnv(jni_env);
   }
-
- private:
-  static inline thread_local int thread_guard_count_ = 0;
-  static inline thread_local ThreadLocalGuardDestructor
-      thread_local_guard_destructor{};
 };
 
-// Represents a runtime instance of a Java Virtual Machine.
-// The caller is responsible for dropping this object from scope when
-// JNI_OnUnload is called.
-//
-// For any new thread spawned, a ThreadGuard must be held.  The caller is
-// responsible for ensuring all ThreadGuards fall from scope before JvmRef falls
-// from scope.
+// Represents a UTF view into a jstring (see jni::String::Pin()).
 //
-// The caller is also responsible for thread safety of all objects that have
-// been built during the lifetime of the JVM.  i.e If any objects have been
-// built, they must fall from scope prior to JvmRef falling from scope.
+// This class will immediately pin memory associated with the jstring, and
+// release on leaving scope. Note, this class will *always* make an expensive
+// copy, as strings are natively represented in Java as Unicode.
 //
-// There should only be one instance of JvmRef created at a time. If the
-// lifetimes of multiple JvmRef overlap, then one instance may get an invalid
-// JavaVM after the first instance is destroyed.
-template <const auto& jvm_v_>
-class JvmRef : public JvmRefBase {
+// (C++20 will offer a compatible std::string_view but C++17 does not).
+class UtfStringView {
  public:
-  template <size_t ClassLoaderIdx>
-  struct TeardownClassesHelper {
-    template <size_t... Is>
-    static constexpr void TeardownClass(
-        std::index_sequence<Is...> index_sequence) {
-      (ClassRef_t<JniT<jobject, kNoClassSpecified, kDefaultClassLoader, jvm_v_,
-                       0, Is, ClassLoaderIdx>
+  UtfStringView(jstring java_string)
+      : java_string_(java_string),
+        chars_(java_string_
+                   ? JniEnv::GetEnv()->GetStringUTFChars(java_string,
+                                                         /*isCopy=*/nullptr)
+                   : nullptr) {}
 
-                  >::MaybeReleaseClassRef(),
-       ...);
+  ~UtfStringView() {
+    if (chars_) {
+      JniHelper::ReleaseStringUTFChars(java_string_, chars_);
     }
-  };
-
-  template <size_t... Is>
-  constexpr void TeardownClassloadersHelper(
-      std::index_sequence<Is...> index_sequence) {
-    (TeardownClassesHelper<Is>::TeardownClass(
-         std::make_index_sequence<
-             std::tuple_size_v<decltype(std::get<Is>(jvm_v_.class_loaders_)
-                                            .supported_classes_)>>()),
-     ...);
   }
 
-  JavaVM* BuildJavaVMFromEnv(JNIEnv* env) {
-    JavaVM* vm = nullptr;
-    // 0 Is success.
-    if (env->GetJavaVM(&vm) == 0) {
-      return vm;
-    } else {
-      return nullptr;
-    }
-  }
+  UtfStringView(UtfStringView&&) = delete;
+  UtfStringView(const UtfStringView&) = delete;
 
-  explicit JvmRef(JNIEnv* env) : JvmRefBase(BuildJavaVMFromEnv(env)) {}
-  explicit JvmRef(JavaVM* vm) : JvmRefBase(vm) {}
+  // Returns a view into the pinned character string.
+  // Warning: std::string_view{nullptr} is undefined behaviour and may crash.
+  const std::string_view ToString() const { return std::string_view{chars_}; }
 
-  ~JvmRef() {
-    TeardownClassloadersHelper(
-        std::make_index_sequence<
-            std::tuple_size_v<decltype(jvm_v_.class_loaders_)>>());
+ private:
+  const jstring java_string_;
+  const char* chars_;
+};
 
-    // This object has two lifecycle phases in relation to data races
-    // 1)  Value is null, when it is guarded by the ClassRef mutex
-    //     (implicitly part of ClassRef's behaviour).
-    // 2)  JVM is tearing down.  At this point, the caller is responsible for
-    //     releasing all native resources.
-    //     ReleaseAllClassRefsForDefaultClassLoader will only ever be torn down
-    //     by JvmRef::~JvmRef, and JvmRef cannot be moved, therefore it is
-    //     guaranteed to be in a single threaded context.
-    auto& default_loaded_class_list = GetDefaultLoadedClassList();
-    for (metaprogramming::DoubleLockedValue<jclass>* maybe_loaded_class_id :
-         default_loaded_class_list) {
-      maybe_loaded_class_id->Reset([](jclass clazz) {
-        LifecycleHelper<jobject, LifecycleType::GLOBAL>::Delete(clazz);
-      });
-    }
-    default_loaded_class_list.clear();
+}  // namespace jni
 
-    // Methods do not need to be released, just forgotten.
-    auto& default_loaded_method_ref_list = GetDefaultLoadedMethodList();
-    for (metaprogramming::DoubleLockedValue<jmethodID>* cached_method_id :
-         default_loaded_method_ref_list) {
-      cached_method_id->Reset();
-    }
-    default_loaded_method_ref_list.clear();
+#include <type_traits>
 
-    // Fields do not need to be released, just forgotten.
-    auto& default_loaded_field_ref_list = GetDefaultLoadedFieldList();
-    for (metaprogramming::DoubleLockedValue<jfieldID>* cached_field_id :
-         default_loaded_field_ref_list) {
-      cached_field_id->Reset();
-    }
-    default_loaded_field_ref_list.clear();
-  }
+namespace jni {
 
-  // Deleted in order to make various threading guarantees (see class_ref.h).
-  JvmRef(const JvmRef&) = delete;
-  JvmRef(JvmRef&&) = delete;
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+using LocalObjectImpl =
+    Scoped<LifecycleType::LOCAL,
+           JniT<jobject, class_v_, class_loader_v_, jvm_v_>, jobject>;
 
-  // All new threads MUST create a guard by calling |BuildThreadGuard|.
-  // If a JNIEnv does not exist, this will DetachCurrentThread when done.
-  [[nodiscard]] ThreadGuard BuildThreadGuard() const { return {}; }
+template <const auto& class_v_,
+          const auto& class_loader_v_ = kDefaultClassLoader,
+          const auto& jvm_v_ = kDefaultJvm>
+class LocalObject : public LocalObjectImpl<class_v_, class_loader_v_, jvm_v_> {
+ public:
+  using Base = LocalObjectImpl<class_v_, class_loader_v_, jvm_v_>;
+  using Base::Base;
 
- private:
-  // Main thread has a JNIEnv just like every other thread.
-  const ThreadGuard thread_guard_ = {};
+  template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
+  LocalObject(LocalObject<class_v, class_loader_v, jvm_v>&& obj)
+      : Base(obj.Release()) {}
 };
 
-JvmRef(JNIEnv*) -> JvmRef<kDefaultJvm>;
-JvmRef(JavaVM*) -> JvmRef<kDefaultJvm>;
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+LocalObject(LocalObject<class_v_, class_loader_v_, jvm_v_>&&)
+    -> LocalObject<class_v_, class_loader_v_, jvm_v_>;
 
 }  // namespace jni
 
-namespace jni {
+#include <iterator>
 
-// Creates an additional reference to the underlying object.
-// When used for local, presumes local, for global, presumes global.
-struct CreateCopy {};
+namespace jni {
 
-// This tag allows the constructor to promote underlying jobject for you.
-struct PromoteToGlobal {};
+// Primitive Rank 1 Arrays.
+template <typename SpanType, std::size_t kRank = 1, typename Enable = void>
+class ArrayView {
+ public:
+  struct Iterator {
+    using iterator_category = std::random_access_iterator_tag;
+    using difference_type = std::size_t;
+    using value_type = SpanType;
+    using pointer = SpanType*;
+    using reference = SpanType&;
 
-// CAUTION: This tag assume the underlying jobject has been pinned as a global.
-// This is atypical when solely using JNI Bind, use with caution.
-struct AdoptGlobal {};
+    Iterator(SpanType* ptr, std::size_t size, std::size_t idx)
+        : size_(size), ptr_(ptr), idx_(idx) {}
 
-template <typename CrtpBase, typename Span, typename... ViableSpans>
-struct LocalCtor : public CrtpBase {
-  using CrtpBase::CrtpBase;
-};
+    Iterator& operator++() {
+      idx_++;
+      return *this;
+    }
 
-// Augments a a local constructor of type |Span| (created by |LoadedBy|).
-// Inheritance and ctor inheritance will continue through |Base|.
-template <typename CrtpBase, typename JniT, typename ViableSpan,
-          typename... ViableSpans>
-struct LocalCtor<CrtpBase, JniT, ViableSpan, ViableSpans...>
-    : public LocalCtor<CrtpBase, JniT, ViableSpans...> {
-  using Base = LocalCtor<CrtpBase, JniT, ViableSpans...>;
-  using Base::Base;
-  using Span = typename JniT::SpanType;
-  using LifecycleT = LifecycleHelper<Span, LifecycleType::LOCAL>;
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
 
-  // "Copy" constructor: Additional reference to object will be created.
-  LocalCtor(CreateCopy, ViableSpan object)
-      : Base(static_cast<Span>(
-            LifecycleT::NewReference(static_cast<Span>(object)))) {}
+    SpanType& operator*() const { return ptr_[idx_]; }
+    const SpanType* operator->() const { return ptr_[idx_]; }
 
-  // "Wrap" constructor: Object released at end of scope.
-  LocalCtor(ViableSpan object) : Base(static_cast<Span>(object)) {}
-};
+    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
+      return (lhs.ptr_ == rhs.ptr_) && (lhs.size_ == rhs.size_) &&
+             (lhs.idx_ == rhs.idx_);
+    };
 
-template <typename CrtpBase, typename JniT, typename... ViableSpans>
-struct GlobalCtor : public CrtpBase {
-  using CrtpBase::CrtpBase;
-};
+    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
+      return !(lhs == rhs);
+    };
 
-// Augments a a local constructor of type |Span| (created by |LoadedBy|).
-// Inheritance and ctor inheritance will continue through |Base|.
-template <typename CrtpBase, typename JniT, typename ViableSpan,
-          typename... ViableSpans>
-struct GlobalCtor<CrtpBase, JniT, ViableSpan, ViableSpans...>
-    : public GlobalCtor<CrtpBase, JniT, ViableSpans...> {
-  using Base = GlobalCtor<CrtpBase, JniT, ViableSpans...>;
-  using Base::Base;
-  using Span = typename JniT::SpanType;
-  using LifecycleT = LifecycleHelper<jobject, LifecycleType::GLOBAL>;
+    friend std::size_t operator-(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.idx_ - rhs.idx_;
+    };
 
-  // "Copy" constructor: Additional reference to object will be created.
-  GlobalCtor(CreateCopy, ViableSpan object)
-      : Base(static_cast<Span>(LifecycleT::NewReference(object))) {}
+   private:
+    const std::size_t size_;
+    SpanType* const ptr_;
+    std::size_t idx_;
+  };
 
-  // "Promote" constructor: Creates new global, frees |obj| (standard).
-  explicit GlobalCtor(PromoteToGlobal, ViableSpan obj)
-      : Base(LifecycleT::Promote(obj)) {}
+  ArrayView(ArrayView&&) = delete;
+  ArrayView(const ArrayView&) = delete;
 
-  // "Adopts" a global by wrapping a jstring (non-standard).
-  explicit GlobalCtor(AdoptGlobal, ViableSpan obj) : Base(obj) {}
-};
+  ArrayView(jarray array, bool copy_on_completion, std::size_t size)
+      : array_(array),
+        get_array_elements_result_(
+            JniArrayHelper<SpanType, kRank>::GetArrayElements(array)),
+        copy_on_completion_(copy_on_completion),
+        size_(size) {}
 
-}  // namespace jni
+  ~ArrayView() {
+    JniArrayHelper<SpanType, kRank>::ReleaseArrayElements(
+        array_, get_array_elements_result_.ptr_, copy_on_completion_);
+  }
 
-#include <optional>
-#include <string>
-#include <type_traits>
-#include <utility>
+  // Arrays of rank > 1 are object arrays which are not contiguous.
+  std::enable_if_t<kRank == 1, SpanType*> ptr() {
+    return get_array_elements_result_.ptr_;
+  }
 
-namespace jni {
+  Iterator begin() { return Iterator{ptr(), size_, 0}; }
+  Iterator end() { return Iterator{ptr(), size_, size_}; }
 
-// Represents a runtime instance of a JNI Object.  Instead of using this class
-// directly, instead the more specialised types such as LocalObject,
-// GlobalObject, etc.
-//
-// To call methods on the object, use the  operator(), to access fields, use
-// operator[].
-template <typename JniT>
-class ObjectRef
-    : public metaprogramming::InvocableMap<
-          ObjectRef<JniT>, JniT::stripped_class_v, typename JniT::ClassT,
-          &JniT::ClassT::methods_>,
-      public metaprogramming::QueryableMap_t<
-          ObjectRef<JniT>, JniT::stripped_class_v, &JniT::ClassT::fields_>,
-      public RefBase<JniT> {
  protected:
-  static_assert(
-      JniT::class_loader_v
-          .template SupportedDirectlyOrIndirectly<JniT::class_v>(),
-      "This class is not directly or indirectly supported by this loader.");
-  static_assert(!metaprogramming::StringContains_v<JniT::kName, '.'>,
-                "Use '/', not '.' in class names (for maximum) portability.");
-
-  using RefBase = RefBase<JniT>;
-
-  ObjectRef() = delete;
-  explicit ObjectRef(ObjectRef&& rhs) = default;
-  ObjectRef(const ObjectRef& rhs) = delete;
-  ObjectRef& operator=(const ObjectRef& rhs) = delete;
-
-  jclass GetJClass() const {
-    return ClassRef_t<JniT>::GetAndMaybeLoadClassRef(RefBase::object_ref_);
-  }
+  const jarray array_;
+  const GetArrayElementsResult<SpanType> get_array_elements_result_;
+  const bool copy_on_completion_;
+  const std::size_t size_;
+};
 
+// Object arrays, or arrays with rank > 1 (which are object arrays), or strings.
+template <typename SpanType, std::size_t kRank>
+class ArrayView<
+    SpanType, kRank,
+    std::enable_if_t<(kRank > 1) || std::is_same_v<SpanType, jobject> ||
+                     std::is_same_v<SpanType, jstring>>> {
  public:
-  explicit ObjectRef(RefBaseTag<typename JniT::StorageType>&& rhs)
-      : RefBase(std::move(rhs)) {}
+  // Metafunction that returns the type after a single dereference.
+  template <std::size_t>
+  struct PinHelper {
+    using type = jobjectArray;
+  };
+  template <>
+  struct PinHelper<2> {
+    using type = RegularToArrayTypeMap_t<SpanType>;
+  };
+  template <>
+  struct PinHelper<1> {
+    using type = jobject;
+  };
 
-  // Invoked through CRTP from InvocableMap.
-  template <size_t I, typename... Args>
-  auto InvocableMapCall(const char* key, Args&&... args) const {
-    using IdT = Id<JniT, IdType::OVERLOAD_SET, I>;
-    using MethodSelectionForArgs =
-        OverloadSelector<IdT, IdType::OVERLOAD, IdType::OVERLOAD_PARAM,
-                         Args...>;
+  using PinHelper_t = typename PinHelper<kRank>::type;
 
-    static_assert(MethodSelectionForArgs::kIsValidArgSet,
-                  "JNI Error: Invalid argument set.");
+  struct Iterator {
+    using iterator_category = std::random_access_iterator_tag;
+    using difference_type = std::size_t;
+    using value_type = PinHelper_t;
+    using pointer = PinHelper_t*;
+    using reference = PinHelper_t&;
 
-    return MethodSelectionForArgs::OverloadRef::Invoke(
-        GetJClass(), RefBase::object_ref_, std::forward<Args>(args)...);
-  }
+    Iterator(jobjectArray arr, std::size_t size, std::size_t idx)
+        : arr_(arr), size_(size), idx_(idx) {}
 
-  // Invoked through CRTP from QueryableMap.
-  template <size_t I>
-  auto QueryableMapCall(const char* key) const {
-    return FieldRef<JniT, IdType::FIELD, I>{GetJClass(), RefBase::object_ref_};
-  }
-};
+    Iterator& operator++() {
+      idx_++;
+      return *this;
+    }
 
-// Imbues constructors for ObjectRefs and handles calling the correct
-// intermediate constructors.  Access to this class is constrainted for non
-// default classloaders (see |ValidatorProxy|).
-template <typename JniT>
-class ConstructorValidator : public ObjectRef<JniT> {
- public:
-  using Base = ObjectRef<JniT>;
-  using Base::Base;
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
 
-  // Objects can still be wrapped.  This could happen if a classloaded object
-  // is built in Java and then passed through to JNI.
-  ConstructorValidator(typename JniT::StorageType obj) : Base(obj) {}
+    PinHelper_t operator*() const {
+      if constexpr (kRank >= 2) {
+        return static_cast<PinHelper_t>(
+            JniArrayHelper<jobject, kRank>::GetArrayElement(arr_, idx_));
+      } else {
+        return JniArrayHelper<SpanType, kRank>::GetArrayElement(arr_, idx_);
+      }
+    }
 
-  template <const auto& jvm_v, const auto& class_loader_v>
-  friend class ClassLoaderRef;
+    friend bool operator==(const Iterator& lhs, const Iterator& rhs) {
+      return (lhs.arr_ == rhs.arr_) && (lhs.size_ == rhs.size_) &&
+             (lhs.idx_ == rhs.idx_);
+    };
 
-  static constexpr std::size_t kNumConstructors =
-      std::tuple_size_v<decltype(JniT::class_v.constructors_)>;
+    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) {
+      return !(lhs == rhs);
+    };
 
-  template <typename... Args>
-  struct Helper {
-    using IdT = Id<JniT, IdType::OVERLOAD_SET, kNoIdx>;
+    friend std::size_t operator-(const Iterator& lhs, const Iterator& rhs) {
+      return lhs.idx_ - rhs.idx_;
+    };
 
-    // 0 is (always) used to represent the constructor.
-    using type = OverloadSelector<IdT, IdType::OVERLOAD, IdType::OVERLOAD_PARAM,
-                                  Args...>;
+   private:
+    jobjectArray const arr_;
+    const std::size_t size_;
+    std::size_t idx_;
   };
 
-  template <typename... Args>
-  using Permutation_t = typename Helper<Args...>::type;
+  ArrayView(ArrayView&&) = delete;
+  ArrayView(const ArrayView&) = delete;
 
-  template <typename... Args,
-            typename std::enable_if<sizeof...(Args) != 0, int>::type = 0>
-  ConstructorValidator(Args&&... args)
-      : Base(static_cast<typename JniT::StorageType>(
-            Permutation_t<Args...>::OverloadRef::Invoke(
-                Base::GetJClass(), Base::object_ref_,
-                std::forward<Args>(args)...)
-                .Release())) {
-    static_assert(Permutation_t<Args...>::kIsValidArgSet,
-                  "You have passed invalid arguments to construct this type.");
-  }
+  ArrayView(jobjectArray array, bool, std::size_t size)
+      : array_(array), size_(size) {}
 
-  ConstructorValidator()
-      : Base(Permutation_t<>::OverloadRef::Invoke(Base::GetJClass(),
-                                                  Base::object_ref_)
-                 .Release()) {}
-};
+  Iterator begin() { return Iterator(array_, size_, 0); }
+  Iterator end() { return Iterator(array_, size_, size_); }
 
-template <typename JniT>
-struct ValidatorProxy : public ConstructorValidator<JniT> {
-  using Base = ConstructorValidator<JniT>;
-  using Base::Base;
+ protected:
+  const jobjectArray array_;
+  const std::size_t size_;
 };
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-using ObjectRefBuilder_t =
-    ValidatorProxy<JniT<jobject, class_v_, class_loader_v_, jvm_v_>>;
+// This CTAD guide is required for materialising new ArrayViews from |Pin()|
+// calls as move and copy constructors are deleted.
+template <typename SpanType, std::size_t kRank>
+ArrayView(ArrayView<SpanType, kRank>&&) -> ArrayView<SpanType, kRank>;
 
 }  // namespace jni
 
-#include <optional>
-#include <string>
-#include <string_view>
-
 namespace jni {
 
-template <typename CrtpBase>
-class StringRefBase
-    : public ConstructorValidator<
-          JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>> {
- public:
-  using ValidT = ConstructorValidator<
-      JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>>;
-  using ValidT::ValidT;
-
-  StringRefBase(std::nullptr_t) : ValidT(jstring{nullptr}) {}
-  StringRefBase(jstring object) : ValidT(object) {}
-
-  ~StringRefBase() {
-    if (object_ref_) {
-      static_cast<CrtpBase&>(*this).ClassSpecificDeleteObjectRef(object_ref_);
-    }
-  }
-};
+using LocalStringImpl =
+    Scoped<LifecycleType::LOCAL, JniT<jstring, kJavaLangString>, jobject,
+           jstring>;
 
-// Represents a UTF view into a jstring (see jni::String::Pin()).
+// Represents and possibly builds a runtime Java String object.
 //
-// This class will immediately pin memory associated with the jstring, and
-// release on leaving scope. Note, this class will *always* make an expensive
-// copy, as strings are natively represented in Java as Unicode.
+// In order to use a string in memory (as opposed to only using it for function
+// arguments), "Pin" the string.
 //
-// (C++20 will offer a compatible std::string_view but C++17 does not).
-class UtfStringView {
+// Like |jobjects|, |jstring|s can be either local or global with the same
+// ownership semantics.
+class LocalString : public LocalStringImpl {
  public:
-  UtfStringView(jstring java_string)
-      : java_string_(java_string),
-        chars_(java_string_
-                   ? JniEnv::GetEnv()->GetStringUTFChars(java_string,
-                                                         /*isCopy=*/nullptr)
-                   : nullptr) {}
-
-  ~UtfStringView() {
-    if (chars_) {
-      JniHelper::ReleaseStringUTFChars(java_string_, chars_);
-    }
-  }
-
-  UtfStringView(UtfStringView&&) = delete;
-  UtfStringView(const UtfStringView&) = delete;
+  using Base = LocalStringImpl;
+  using Base::Base;
 
-  // Returns a view into the pinned character string.
-  // Warning: std::string_view{nullptr} is undefined behaviour and may crash.
-  const std::string_view ToString() const { return std::string_view{chars_}; }
+  LocalString(std::nullptr_t) : Base(jstring{nullptr}) {}
+  LocalString(LocalObject<kJavaLangString>&& obj)
+      : Base(static_cast<jstring>(obj.Release())) {}
 
- private:
-  const jstring java_string_;
-  const char* chars_;
+  // Returns a StringView which possibly performs an expensive pinning
+  // operation.  String objects can be pinned multiple times.
+  UtfStringView Pin() { return {RefBaseTag<jstring>::object_ref_}; }
 };
 
 }  // namespace jni
 
-#include <type_traits>
-
 namespace jni {
 
-// Represents a "Local" JNI reference of a class.  This object is *not* thread
-// safe, but can be promoted to a GlobalObject which *is* thread safe.
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+using GlobalObjectImpl =
+    Scoped<LifecycleType::GLOBAL,
+           JniT<jobject, class_v_, class_loader_v_, jvm_v_>, jobject>;
+
 template <const auto& class_v_,
           const auto& class_loader_v_ = kDefaultClassLoader,
           const auto& jvm_v_ = kDefaultJvm>
-class LocalObject
-    : public LocalCtor<ObjectRefBuilder_t<class_v_, class_loader_v_, jvm_v_>,
-                       JniT<jobject, class_v_, class_loader_v_, jvm_v_>,
-                       jobject> {
+class GlobalObject
+    : public GlobalObjectImpl<class_v_, class_loader_v_, jvm_v_> {
  public:
-  using Base =
-      LocalCtor<ObjectRefBuilder_t<class_v_, class_loader_v_, jvm_v_>,
-                JniT<jobject, class_v_, class_loader_v_, jvm_v_>, jobject>;
+  using Base = GlobalObjectImpl<class_v_, class_loader_v_, jvm_v_>;
   using Base::Base;
+  using LifecycleT = LifecycleHelper<jobject, LifecycleType::GLOBAL>;
 
   template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-  LocalObject(LocalObject<class_v, class_loader_v, jvm_v>&& rhs)
-      : Base(rhs.Release()) {
-    static_assert(
-        std::string_view(class_v.name_) == std::string_view(class_v_.name_),
-        "You are attempting to initialise a LocalObject from another class "
-        "type");
+  GlobalObject(GlobalObject<class_v, class_loader_v, jvm_v>&& obj)
+      : Base(obj.Release()) {}
+
+  template <typename... Ts>
+  GlobalObject(Ts&&... vals) : Base(std::forward<Ts&&>(vals)...) {
+    RefBaseTag<jobject>::object_ref_ =
+        LifecycleT::Promote(RefBaseTag<jobject>::object_ref_);
   }
 
-  ~LocalObject() {
-    if (Base::object_ref_) {
-      LifecycleHelper<jobject, LifecycleType::LOCAL>::Delete(Base::object_ref_);
-    }
+  GlobalObject() {
+    RefBaseTag<jobject>::object_ref_ =
+        LifecycleT::Promote(RefBaseTag<jobject>::object_ref_);
   }
 };
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-LocalObject(LocalObject<class_v_, class_loader_v_, jvm_v_>&&)
-    -> LocalObject<class_v_, class_loader_v_, jvm_v_>;
+template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
+GlobalObject(LocalObject<class_v, class_loader_v, jvm_v>&&)
+    -> GlobalObject<class_v, class_loader_v, jvm_v>;
 
 }  // namespace jni
 
-
 namespace jni {
 
-// Represents and possibly builds a runtime Java String object.
-//
-// In order to use a string in memory (as opposed to only using it for function
-// arguments), "Pin" the string.
-//
-// Like |jobjects|, |jstring|s can be either local or global with the same
-// ownership semantics.
-class LocalString
-    : public LocalCtor<
-          StringRefBase<LocalString>,
-          JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>,
-          jobject, jstring> {
+// Note: All arrays are local (global arrays of local objects is too confusing).
+template <typename JniT>
+using ScopedArrayImpl =
+    Scoped<LifecycleType::LOCAL, JniT, jarray, typename JniT::StorageType>;
+
+// |SpanType| is primitive types like jint, jfloat, etc.
+template <typename JniT, typename Enable = void>
+class ArrayRef : public ScopedArrayImpl<JniT> {
  public:
-  friend StringRefBase<LocalString>;
+  using Base = ScopedArrayImpl<JniT>;
 
-  using Base = LocalCtor<
-      StringRefBase<LocalString>,
-      JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>, jobject,
-      jstring>;
   using Base::Base;
+  using SpanType = typename JniT::SpanType;
 
-  LocalString(
-      LocalObject<kJavaLangString, kDefaultClassLoader, kDefaultJvm>&& obj)
-      : Base(static_cast<jstring>(obj.Release())) {}
+  ArrayRef(std::nullptr_t) {}
+  ArrayRef(std::size_t size)
+      : Base(JniArrayHelper<SpanType, JniT::kRank>::NewArray(size)) {}
 
-  // Returns a StringView which possibly performs an expensive pinning
-  // operation.  String objects can be pinned multiple times.
-  UtfStringView Pin() { return {RefBaseTag<jstring>::object_ref_}; }
+  explicit ArrayRef(int size) : ArrayRef(static_cast<std::size_t>(size)) {}
 
- private:
-  // Invoked through CRTP on dtor.
-  void ClassSpecificDeleteObjectRef(jstring object_ref) {
-    if (Base::object_ref_) {
-      LifecycleHelper<jstring, LifecycleType::LOCAL>::Delete(object_ref);
-    }
+  ArrayView<SpanType, JniT::kRank> Pin(bool copy_on_completion = true) {
+    return {Base::object_ref_, copy_on_completion, Length()};
+  }
+
+  std::size_t Length() {
+    return JniArrayHelper<SpanType, JniT::kRank>::GetLength(Base::object_ref_);
+  }
+};
+
+// |SpanType| is object.
+template <typename JniT>
+class ArrayRef<
+    JniT, std::enable_if_t<std::is_same_v<typename JniT::SpanType, jobject>>>
+    : public ScopedArrayImpl<JniT> {
+ public:
+  using Base = ScopedArrayImpl<JniT>;
+  using Base::Base;
+  using SpanType = jobject;
+
+  // Construct array with given size and null values.
+  explicit ArrayRef(std::size_t size)
+      : Base(JniArrayHelper<jobject, JniT::kRank>::NewArray(
+            size, ClassRef_t<JniT>::GetAndMaybeLoadClassRef(nullptr),
+            static_cast<jobject>(nullptr))) {}
+
+  // Construct from jobject lvalue (object is used as template).
+  explicit ArrayRef(std::size_t size, jobject obj)
+      : Base(JniArrayHelper<jobject, JniT::kRank>::NewArray(
+            size,
+            ClassRef_t<JniT>::GetAndMaybeLoadClassRef(
+                static_cast<jobject>(obj)),
+            static_cast<jobject>(obj))) {}
+
+  // Construct from LocalObject lvalue (object is used as template).
+  //
+  // e.g.
+  //  LocalArray arr { 5, LocalObject<kClass> {args...} };
+  //  LocalArray arr { 5, GlobalObject<kClass> {args...} };
+  template <template <const auto&, const auto&, const auto&>
+            class ObjectContainer,
+            const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
+  ArrayRef(std::size_t size,
+           const ObjectContainer<class_v, class_loader_v, jvm_v>& obj)
+      : ArrayRef(size, static_cast<jobject>(obj)) {}
+
+  std::size_t Length() {
+    return JniArrayHelper<jobject, JniT::kRank>::GetLength(Base::object_ref_);
+  }
+
+  // Object arrays cannot be efficiently pinned like primitive types can.
+  ArrayView<jobject, JniT::kRank> Pin() {
+    return {Base::object_ref_, false, Length()};
+  }
+
+  LocalObject<JniT::class_v, JniT::class_loader_v, JniT::jvm_v> Get(
+      std::size_t idx) {
+    return {JniArrayHelper<jobject, JniT::kRank>::GetArrayElement(
+        Base::object_ref_, idx)};
+  }
+
+  // Note: Globals are not permitted in a local array because it makes reasoning
+  // about them confusing.
+  //
+  // TODO(b/406948932): Permit lvalues of locals and globals as technically
+  // they're both viable (the scope will be extended as expected).
+  void Set(
+      std::size_t idx,
+      LocalObject<JniT::class_v, JniT::class_loader_v, JniT::jvm_v>&& val) {
+    return JniArrayHelper<jobject, JniT::kRank>::SetArrayElement(
+        Base::object_ref_, idx, val.Release());
   }
 };
 
 }  // namespace jni
 
-namespace jni {
+#include <cstddef>
+#include <type_traits>
 
-template <const auto& jvm_v_, const auto& class_loader_v_>
-class ClassLoaderRef;
+namespace jni {
 
-template <const auto& class_v_,
+// Represents a an array object (e.g. int[], float[][], Object[], etc).
+// Currently GlobalArrays do not exist, as reasoning about the lifecycles of the
+// underlying objects is non-trivial, e.g. a GlobalArray taking a local object
+// would result in a possibly unexpected extension of lifetime.
+template <typename SpanType, std::size_t kRank_ = 1,
+          const auto& class_v_ = kNoClassSpecified,
           const auto& class_loader_v_ = kDefaultClassLoader,
           const auto& jvm_v_ = kDefaultJvm>
-class GlobalObject
-    : public GlobalCtor<ObjectRefBuilder_t<class_v_, class_loader_v_, jvm_v_>,
-                        JniT<jobject, class_v_, class_loader_v_, jvm_v_>,
-
-                        jobject> {
+class LocalArray
+    : public ArrayRef<
+          JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>> {
  public:
-  template <const auto& jvm_v, const auto& class_loader_v>
-  friend class ClassLoaderRef;
+  using JniT_ = JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>;
+  using ObjectClassRefT = ClassRef_t<JniT_>;
 
   using Base =
-      GlobalCtor<ObjectRefBuilder_t<class_v_, class_loader_v_, jvm_v_>,
-                 JniT<jobject, class_v_, class_loader_v_, jvm_v_>, jobject>;
+      ArrayRef<JniT<SpanType, class_v_, class_loader_v_, jvm_v_, kRank_>>;
   using Base::Base;
 
-  using LifecycleT = LifecycleHelper<jobject, LifecycleType::GLOBAL>;
-
-  // Constructs a new global object using the local object's default
-  // constructor.
-  explicit GlobalObject()
-      : GlobalObject(LifecycleT::Promote(
-            LocalObject<class_v_, class_loader_v_, jvm_v_>{}.Release())) {}
-
-  template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-  GlobalObject(LocalObject<class_v, class_loader_v, jvm_v>&& local_object)
-      : Base(LifecycleT::Promote(local_object.Release())) {
-    static_assert(
-        std::string_view(class_v.name_) == std::string_view(class_v_.name_),
-        "You are attempting to initialise a LocalObject from another class "
-        "type");
-  }
+  LocalArray(LocalArray<SpanType, kRank_>&& rhs) : Base(rhs.Release()) {}
 
-  template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-  GlobalObject(GlobalObject<class_v, class_loader_v, jvm_v>&& rhs)
+  template <std::size_t kRank, const auto& class_v, const auto& class_loader_v,
+            const auto& jvm_v>
+  LocalArray(LocalArray<jobject, kRank, class_v, class_loader_v, jvm_v>&& rhs)
       : Base(rhs.Release()) {
-    static_assert(
-        std::string_view(class_v.name_) == std::string_view(class_v_.name_),
-        "You are attempting to initialise a GlobalObject from another class "
-        "type");
+    static_assert(kRank == kRank_ && class_v == class_v_ &&
+                  class_loader_v == class_loader_v_);
   }
+};
 
-  // Constructs a new object using arg based ctor.
-  template <typename... Ts>
-  explicit GlobalObject(Ts&&... ts)
-      : GlobalObject(
-            LifecycleT::Promote(LocalObject<class_v_, class_loader_v_, jvm_v_>{
-                std::forward<Ts>(ts)...}
-                                    .Release())) {}
+template <template <const auto&, const auto&, const auto&>
+          class ObjectContainer,
+          const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+LocalArray(std::size_t,
+           const ObjectContainer<class_v_, class_loader_v_, jvm_v_>&)
+    -> LocalArray<jobject, class_v_, class_loader_v_, jvm_v_>;
 
-  GlobalObject(const GlobalObject&) = delete;
-  GlobalObject(GlobalObject&& rhs) = default;
+template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
+LocalArray(
+    std::size_t,
+    const Scoped<LifecycleType::LOCAL,
+                 JniT<jobject, class_v_, class_loader_v_, jvm_v_>, jobject>&)
+    -> LocalArray<jobject, class_v_, class_loader_v_, jvm_v_>;
 
-  ~GlobalObject() {
-    if (Base::object_ref_) {
-      LifecycleT::Delete(Base::object_ref_);
-    }
-  }
+template <typename SpanType>
+LocalArray(std::size_t, SpanType)
+    -> LocalArray<SpanType, 1, kNoClassSpecified, kDefaultClassLoader,
+                  kDefaultJvm>;
 
- private:
-  // Construction from jobject requires |PromoteToGlobal| or |AdoptGlobal|.
-  explicit GlobalObject(jobject obj) : Base(obj) {}
-};
+template <const auto& kArrayVal>
+struct LocalArrayBuildFromArray_Helper {};
 
-template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
-GlobalObject(LocalObject<class_v, class_loader_v, jvm_v>&&)
-    -> GlobalObject<class_v, class_loader_v, jvm_v>;
+template <typename TUndecayed>
+struct ProxyHelper;
 
 }  // namespace jni
 
@@ -7191,10 +7381,13 @@ GlobalObject(LocalObject<class_v, class_loader_v, jvm_v>&&)
 
 namespace jni {
 
-template <const auto& jvm_v_, const auto& class_loader_v_>
-class ClassLoaderRef
-    : public ObjectRef<JniT<jobject, kJavaLangClassLoader, kDefaultClassLoader,
-                            kDefaultJvm>> {
+template <LifecycleType lifecycleType>
+using ClassLoaderImpl =
+    Scoped<lifecycleType, JniT<jobject, kJavaLangClassLoader>, jobject>;
+
+template <LifecycleType lifecycleType, const auto& class_loader_v_,
+          const auto& jvm_v_>
+class ClassLoaderRef : public ClassLoaderImpl<lifecycleType> {
  private:
   // Returns kDefaultJvm for default class loaded objects, otherwise returns the
   // jvm associated with this loader.  Default loaders do not use indexing,
@@ -7210,9 +7403,8 @@ class ClassLoaderRef
   }
 
  public:
-  ClassLoaderRef(jobject class_loader)
-      : ObjectRef<JniT<jobject, kJavaLangClassLoader, kDefaultClassLoader,
-                       kDefaultJvm>>(class_loader) {}
+  using Base = ClassLoaderImpl<lifecycleType>;
+  using Base::Base;
 
   static_assert(class_loader_v_ != kDefaultClassLoader,
                 "Custom class loaders should not use the default class loader,"
@@ -7257,13 +7449,12 @@ class ClassLoaderRef
 
     return GlobalObject<class_v,
                         ParentLoaderForClass<class_loader_v_, class_v>(),
-                        JvmForLoader<class_v>()>{promoted_local};
+                        JvmForLoader<class_v>()>{AdoptGlobal{}, promoted_local};
   }
 };
 
 }  // namespace jni
 
-
 namespace jni {
 
 template <typename CrtpBase_, const auto& class_v_, const auto& class_loader_v_,
@@ -7330,18 +7521,15 @@ struct StaticRef
 namespace jni {
 
 template <const auto& class_loader_v_, const auto& jvm_v_ = kDefaultJvm>
-class LocalClassLoader : public ClassLoaderRef<jvm_v_, class_loader_v_> {
+class LocalClassLoader
+    : public ClassLoaderRef<LifecycleType::LOCAL, class_loader_v_, jvm_v_> {
  public:
-  using Base = ClassLoaderRef<jvm_v_, class_loader_v_>;
-
-  LocalClassLoader(jobject class_loader)
-      : ClassLoaderRef<jvm_v_, class_loader_v_>(class_loader) {}
+  using Base = ClassLoaderRef<LifecycleType::LOCAL, class_loader_v_, jvm_v_>;
+  using Base::Base;
 
-  ~LocalClassLoader() {
-    if (Base::object_ref_) {
-      LifecycleHelper<jobject, LifecycleType::LOCAL>::Delete(Base::object_ref_);
-    }
-  }
+  template <const auto& class_loader_v, const auto& jvm_v>
+  explicit LocalClassLoader(LocalClassLoader<class_loader_v, jvm_v>&& lhs)
+      : LocalClassLoader(lhs.Release()) {}
 
  private:
   template <typename>
@@ -7355,12 +7543,6 @@ class LocalClassLoader : public ClassLoaderRef<jvm_v_, class_loader_v_> {
 
 namespace jni {
 
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class LocalObject;
-
-template <const auto& class_v_, const auto& class_loader_v_, const auto& jvm_v_>
-class GlobalObject;
-
 template <std::size_t kRank_, const auto& class_v_, const auto& class_loader_v_,
           const auto& jvm_v_>
 class LocalArray<jstring, kRank_, class_v_, class_loader_v_, jvm_v_>
@@ -7392,24 +7574,29 @@ class LocalArray<jstring, kRank_, class_v_, class_loader_v_, jvm_v_>
     return JniArrayHelper<jobject, kRank_>::SetArrayElement(Base::object_ref_,
                                                             idx, val.Release());
   }
+
+  void Set(std::size_t idx, const char* val) { Set(idx, LocalString{val}); }
+
+  void Set(std::size_t idx, std::string val) {
+    Set(idx, LocalString{std::move(val)});
+  }
+
+  void Set(std::size_t idx, std::string_view val) {
+    Set(idx, LocalString{val});
+  }
 };
 
 }  // namespace jni
 
 namespace jni {
 
-class GlobalString
-    : public GlobalCtor<
-          StringRefBase<GlobalString>,
-          JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>,
-          jobject, jstring> {
- public:
-  friend class StringRefBase<GlobalString>;
+using GlobalStringImpl =
+    Scoped<LifecycleType::GLOBAL, JniT<jstring, kJavaLangString>, jobject,
+           jstring>;
 
-  using Base = GlobalCtor<
-      StringRefBase<GlobalString>,
-      JniT<jstring, kJavaLangString, kDefaultClassLoader, kDefaultJvm>, jobject,
-      jstring>;
+class GlobalString : public GlobalStringImpl {
+ public:
+  using Base = GlobalStringImpl;
   using Base::Base;
 
   using LifecycleT = LifecycleHelper<jstring, LifecycleType::GLOBAL>;
@@ -7424,18 +7611,6 @@ class GlobalString
   // Returns a StringView which possibly performs an expensive pinning
   // operation.  String objects can be pinned multiple times.
   UtfStringView Pin() { return {RefBaseTag<jstring>::object_ref_}; }
-
- private:
-  // Construction from jstring requires |PromoteToGlobal| or |AdoptGlobal|.
-  explicit GlobalString(jstring obj) : Base(obj) {}
-
-  // Construction from jstring requires |PromoteToGlobal| or |AdoptGlobal|.
-  explicit GlobalString(jobject obj) : Base(static_cast<jstring>(obj)) {}
-
-  // Invoked through CRTP on dtor.
-  void ClassSpecificDeleteObjectRef(jstring object_ref) {
-    LifecycleT::Delete(object_ref);
-  }
 };
 
 }  // namespace jni
@@ -7443,24 +7618,15 @@ class GlobalString
 namespace jni {
 
 template <const auto& class_loader_v_, const auto& jvm_v_ = kDefaultJvm>
-class GlobalClassLoader : public ClassLoaderRef<jvm_v_, class_loader_v_> {
+class GlobalClassLoader
+    : public ClassLoaderRef<LifecycleType::GLOBAL, class_loader_v_, jvm_v_> {
  public:
-  using Base = ClassLoaderRef<jvm_v_, class_loader_v_>;
-  using LifecycleT = LifecycleHelper<jobject, LifecycleType::GLOBAL>;
-
-  GlobalClassLoader(jobject class_loader)
-      : ClassLoaderRef<jvm_v_, class_loader_v_>(
-            LifecycleT::Promote(class_loader)) {}
+  using Base = ClassLoaderRef<LifecycleType::GLOBAL, class_loader_v_, jvm_v_>;
+  using Base::Base;
 
   template <const auto& class_loader_v, const auto& jvm_v>
   GlobalClassLoader(GlobalClassLoader<class_loader_v, jvm_v>&& rhs)
       : Base(rhs.Release()) {}
-
-  ~GlobalClassLoader() {
-    if (Base::object_ref_) {
-      LifecycleT::Delete(Base::object_ref_);
-    }
-  }
 };
 
 }  // namespace jni
diff --git a/jni_bind_release_leader.inc b/jni_bind_release_leader.inc
index 91f0f29f..1ebffbf9 100644
--- a/jni_bind_release_leader.inc
+++ b/jni_bind_release_leader.inc
@@ -15,7 +15,7 @@
  */
 
 /*******************************************************************************
- * JNI Bind Version 0.9.5.
+ * JNI Bind Version 0.9.6.
  * Alpha Public Release.
  ********************************************************************************
  * This header is the single header version which you can use to quickly test or