diff --git a/CMakeLists.txt b/CMakeLists.txt
index acf5a42ee..7c9878919 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,6 @@ if(NOT JSONSCHEMA_PORTABLE OR APPLE)
 endif()
 
 find_package(Blaze REQUIRED)
-find_package(JSONBinPack REQUIRED)
 
 add_subdirectory(src)
 
diff --git a/DEPENDENCIES b/DEPENDENCIES
index 1e8320598..388956aad 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -1,5 +1,4 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core 9889529cd1d863eb39fc77289581414a183cce19
-jsonbinpack https://github.com/sourcemeta/jsonbinpack 147050385dce7086a28ce93e18a4c3baa9719136
-blaze https://github.com/sourcemeta/blaze 53b3d89652504c1d61f908c8eb25ee3b46921e0b
+core https://github.com/sourcemeta/core 7e3e5ee79ae79d2111a976d8d365cc6818661b47
+blaze https://github.com/sourcemeta/blaze 2c5efbd14f5f24dbe3860be8c8d80279edc20d10
 ctrf https://github.com/ctrf-io/ctrf 93ea827d951390190171d37443bff169cf47c808
diff --git a/cmake/FindJSONBinPack.cmake b/cmake/FindJSONBinPack.cmake
deleted file mode 100644
index 95c58f3ea..000000000
--- a/cmake/FindJSONBinPack.cmake
+++ /dev/null
@@ -1,5 +0,0 @@
-if(NOT JSONBinPack_FOUND)
-  set(JSONBINPACK_INSTALL OFF CACHE BOOL "disable installation")
-  add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/jsonbinpack")
-  set(JSONBinPack_FOUND ON)
-endif()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 689c42f1c..4894865fd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -40,8 +40,7 @@ target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::jsonschema)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::openapi)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::editor)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::configuration)
-target_link_libraries(jsonschema_cli PRIVATE sourcemeta::jsonbinpack::compiler)
-target_link_libraries(jsonschema_cli PRIVATE sourcemeta::jsonbinpack::runtime)
+target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::binpack)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::compiler)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::evaluator)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::output)
diff --git a/src/command_decode.cc b/src/command_decode.cc
index df0487b1e..f886898b2 100644
--- a/src/command_decode.cc
+++ b/src/command_decode.cc
@@ -2,8 +2,7 @@
 #include <sourcemeta/core/json.h>
 #include <sourcemeta/core/jsonschema.h>
 
-#include <sourcemeta/jsonbinpack/compiler.h>
-#include <sourcemeta/jsonbinpack/runtime.h>
+#include <sourcemeta/blaze/binpack.h>
 
 #include <filesystem> // std::filesystem
 #include <fstream>    // std::ifstream
@@ -50,9 +49,9 @@ auto sourcemeta::jsonschema::decode(const sourcemeta::core::Options &options)
   const auto &custom_resolver{
       resolver(options, options.contains("http"), dialect, configuration)};
 
-  sourcemeta::jsonbinpack::compile(schema, sourcemeta::core::schema_walker,
-                                   custom_resolver);
-  const auto encoding{sourcemeta::jsonbinpack::load(schema)};
+  sourcemeta::blaze::binpack_compile(schema, sourcemeta::core::schema_walker,
+                                     custom_resolver);
+  const auto encoding{sourcemeta::blaze::binpack_load(schema)};
 
   auto input_stream{sourcemeta::core::read_file(options.positional().front())};
 
@@ -60,7 +59,7 @@ auto sourcemeta::jsonschema::decode(const sourcemeta::core::Options &options)
   std::ofstream output_stream(sourcemeta::core::weakly_canonical(output),
                               std::ios::binary);
   output_stream.exceptions(std::ios_base::badbit);
-  sourcemeta::jsonbinpack::Decoder decoder{input_stream};
+  sourcemeta::blaze::BinPackDecoder decoder{input_stream};
 
   try {
     if (output.extension() == ".jsonl") {
diff --git a/src/command_encode.cc b/src/command_encode.cc
index 84f21e515..ce31bcb41 100644
--- a/src/command_encode.cc
+++ b/src/command_encode.cc
@@ -4,8 +4,7 @@
 #include <sourcemeta/core/jsonschema.h>
 #include <sourcemeta/core/yaml.h>
 
-#include <sourcemeta/jsonbinpack/compiler.h>
-#include <sourcemeta/jsonbinpack/runtime.h>
+#include <sourcemeta/blaze/binpack.h>
 
 #include <filesystem> // std::filesystem
 #include <fstream>    // std::ofstream
@@ -41,9 +40,9 @@ auto sourcemeta::jsonschema::encode(const sourcemeta::core::Options &options)
   const auto &custom_resolver{
       resolver(options, options.contains("http"), dialect, configuration)};
 
-  sourcemeta::jsonbinpack::compile(schema, sourcemeta::core::schema_walker,
-                                   custom_resolver);
-  const auto encoding{sourcemeta::jsonbinpack::load(schema)};
+  sourcemeta::blaze::binpack_compile(schema, sourcemeta::core::schema_walker,
+                                     custom_resolver);
+  const auto encoding{sourcemeta::blaze::binpack_load(schema)};
 
   const std::filesystem::path document{options.positional().front()};
   const auto original_size{std::filesystem::file_size(document)};
@@ -60,7 +59,7 @@ auto sourcemeta::jsonschema::encode(const sourcemeta::core::Options &options)
         sourcemeta::core::weakly_canonical(options.positional().at(1)),
         std::ios::binary);
     output_stream.exceptions(std::ios_base::badbit);
-    sourcemeta::jsonbinpack::Encoder encoder{output_stream};
+    sourcemeta::blaze::BinPackEncoder encoder{output_stream};
     std::size_t count{0};
     for (const auto &entry : sourcemeta::core::JSONL{stream}) {
       LOG_VERBOSE(options) << "Encoding entry #" << count << "\n";
@@ -87,7 +86,7 @@ auto sourcemeta::jsonschema::encode(const sourcemeta::core::Options &options)
         sourcemeta::core::weakly_canonical(options.positional().at(1)),
         std::ios::binary);
     output_stream.exceptions(std::ios_base::badbit);
-    sourcemeta::jsonbinpack::Encoder encoder{output_stream};
+    sourcemeta::blaze::BinPackEncoder encoder{output_stream};
     encoder.write(entry, encoding);
     output_stream.flush();
     const auto total_size{static_cast<std::uint64_t>(output_stream.tellp())};
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9736c80e9..17e37c09a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -440,6 +440,8 @@ add_jsonschema_test(validate/pass_entrypoint_pointer)
 add_jsonschema_test(validate/pass_entrypoint_pointer_fragment)
 add_jsonschema_test(validate/pass_entrypoint_pointer_space)
 add_jsonschema_test(validate/pass_entrypoint_pointer_fragment_space)
+add_jsonschema_test(validate/pass_entrypoint_pointer_escaped)
+add_jsonschema_test(validate/pass_entrypoint_pointer_fragment_escaped)
 add_jsonschema_test(validate/pass_entrypoint_uri)
 add_jsonschema_test(validate/fail_entrypoint_invalid_pointer)
 add_jsonschema_test(validate/fail_entrypoint_invalid_pointer_escape)
@@ -997,6 +999,8 @@ add_jsonschema_test(compile/pass_entrypoint_pointer)
 add_jsonschema_test(compile/pass_entrypoint_pointer_fragment)
 add_jsonschema_test(compile/pass_entrypoint_pointer_space)
 add_jsonschema_test(compile/pass_entrypoint_pointer_fragment_space)
+add_jsonschema_test(compile/pass_entrypoint_pointer_escaped)
+add_jsonschema_test(compile/pass_entrypoint_pointer_fragment_escaped)
 add_jsonschema_test(compile/pass_entrypoint_uri)
 add_jsonschema_test(compile/fail_entrypoint_invalid_pointer)
 add_jsonschema_test(compile/fail_entrypoint_invalid_pointer_escape)
diff --git a/test/compile/pass_entrypoint_pointer_escaped.clitest b/test/compile/pass_entrypoint_pointer_escaped.clitest
new file mode 100644
index 000000000..65e294fb7
--- /dev/null
+++ b/test/compile/pass_entrypoint_pointer_escaped.clitest
@@ -0,0 +1,49 @@
+WRITE schema.json UNTIL EOF
+{
+  "$id": "https://example.com/schema",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$defs": {
+    "My:Name": {
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}
+EOF
+
+RUN compile schema.json --entrypoint '/$$defs/My%3AName' STDIN /dev/null IN . INTO result.txt EXPECTING 0
+
+WRITE expected.txt UNTIL EOF
+1> [
+1>   9,
+1>   false,
+1>   true,
+1>   [
+1>     [
+1>       [
+1>         22,
+1>         [ "minLength" ],
+1>         [],
+1>         "https://example.com/schema#/$defs/My:Name/minLength",
+1>         2,
+1>         1,
+1>         [ 10, 0 ]
+1>       ],
+1>       [
+1>         11,
+1>         [ "type" ],
+1>         [],
+1>         "https://example.com/schema#/$defs/My:Name/type",
+1>         2,
+1>         1,
+1>         [ 8, 4 ]
+1>       ]
+1>     ]
+1>   ],
+1>   [],
+1>   [ "https://json-schema.org/draft/2020-12/vocab/validation" ]
+1> ]
+EOF
+
+COMPARE result.txt AGAINST expected.txt
diff --git a/test/compile/pass_entrypoint_pointer_fragment_escaped.clitest b/test/compile/pass_entrypoint_pointer_fragment_escaped.clitest
new file mode 100644
index 000000000..f4a9edd4d
--- /dev/null
+++ b/test/compile/pass_entrypoint_pointer_fragment_escaped.clitest
@@ -0,0 +1,49 @@
+WRITE schema.json UNTIL EOF
+{
+  "$id": "https://example.com/schema",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$defs": {
+    "My:Name": {
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}
+EOF
+
+RUN compile schema.json --entrypoint '#/$$defs/My%3AName' STDIN /dev/null IN . INTO result.txt EXPECTING 0
+
+WRITE expected.txt UNTIL EOF
+1> [
+1>   9,
+1>   false,
+1>   true,
+1>   [
+1>     [
+1>       [
+1>         22,
+1>         [ "minLength" ],
+1>         [],
+1>         "https://example.com/schema#/$defs/My:Name/minLength",
+1>         2,
+1>         1,
+1>         [ 10, 0 ]
+1>       ],
+1>       [
+1>         11,
+1>         [ "type" ],
+1>         [],
+1>         "https://example.com/schema#/$defs/My:Name/type",
+1>         2,
+1>         1,
+1>         [ 8, 4 ]
+1>       ]
+1>     ]
+1>   ],
+1>   [],
+1>   [ "https://json-schema.org/draft/2020-12/vocab/validation" ]
+1> ]
+EOF
+
+COMPARE result.txt AGAINST expected.txt
diff --git a/test/validate/pass_entrypoint_pointer_escaped.clitest b/test/validate/pass_entrypoint_pointer_escaped.clitest
new file mode 100644
index 000000000..c758b53a9
--- /dev/null
+++ b/test/validate/pass_entrypoint_pointer_escaped.clitest
@@ -0,0 +1,26 @@
+WRITE schema.json UNTIL EOF
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$defs": {
+    "My:Name": {
+      "type": "integer",
+      "minimum": 1
+    }
+  }
+}
+EOF
+
+WRITE instance.json UNTIL EOF
+42
+EOF
+
+RUN validate schema.json instance.json --entrypoint '/$$defs/My%3AName' --verbose STDIN /dev/null IN . INTO result.txt EXPECTING 0
+
+WRITE expected.txt UNTIL EOF
+2> ok: instance.json
+2>
+2> 1 validated, 1 passed, 0 failed
+EOF
+
+COMPARE result.txt AGAINST expected.txt
diff --git a/test/validate/pass_entrypoint_pointer_fragment_escaped.clitest b/test/validate/pass_entrypoint_pointer_fragment_escaped.clitest
new file mode 100644
index 000000000..2b6f1258e
--- /dev/null
+++ b/test/validate/pass_entrypoint_pointer_fragment_escaped.clitest
@@ -0,0 +1,26 @@
+WRITE schema.json UNTIL EOF
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$defs": {
+    "My:Name": {
+      "type": "integer",
+      "minimum": 1
+    }
+  }
+}
+EOF
+
+WRITE instance.json UNTIL EOF
+42
+EOF
+
+RUN validate schema.json instance.json --entrypoint '#/$$defs/My%3AName' --verbose STDIN /dev/null IN . INTO result.txt EXPECTING 0
+
+WRITE expected.txt UNTIL EOF
+2> ok: instance.json
+2>
+2> 1 validated, 1 passed, 0 failed
+EOF
+
+COMPARE result.txt AGAINST expected.txt
diff --git a/vendor/blaze/DEPENDENCIES b/vendor/blaze/DEPENDENCIES
index 3feeb9892..2be881d73 100644
--- a/vendor/blaze/DEPENDENCIES
+++ b/vendor/blaze/DEPENDENCIES
@@ -1,3 +1,3 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core 9889529cd1d863eb39fc77289581414a183cce19
+core https://github.com/sourcemeta/core 7e3e5ee79ae79d2111a976d8d365cc6818661b47
 jsonschema-test-suite https://github.com/json-schema-org/JSON-Schema-Test-Suite 6648e8194c69697b2e1a15fe76a06a480b183a51
diff --git a/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h b/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h
index 20c92a82c..2ffe0b2d3 100644
--- a/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h
+++ b/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h
@@ -409,9 +409,10 @@ auto to_pointer(
     -> Pointer;
 
 /// @ingroup jsonpointer
-/// Parse the URI fragment representation of a JSON Pointer, percent-decoding
-/// the fragment data before interpretation as mandated by RFC 3986, Section
-/// 2.4 and RFC 6901, Section 6. The result is not set if the URI has no
+/// Parse the URI fragment representation of a JSON Pointer. Reference tokens
+/// are separated before their octets are decoded, so a percent-encoded slash
+/// neither separates two tokens, per RFC 3986, Section 2.2, nor belongs to
+/// one, per RFC 6901, Section 3. The result is not set if the URI has no
 /// fragment or if its fragment is not a valid JSON Pointer. For example:
 ///
 /// ```cpp
diff --git a/vendor/core/src/core/jsonpointer/jsonpointer.cc b/vendor/core/src/core/jsonpointer/jsonpointer.cc
index 67470cbf0..983f5cc63 100644
--- a/vendor/core/src/core/jsonpointer/jsonpointer.cc
+++ b/vendor/core/src/core/jsonpointer/jsonpointer.cc
@@ -11,7 +11,6 @@
 #include "stringify.h"
 
 #include <cassert>     // assert
-#include <cstddef>     // std::size_t
 #include <iterator>    // std::cbegin, std::cend, std::prev, std::advance
 #include <memory>      // std::allocator
 #include <optional>    // std::optional, std::nullopt
@@ -24,6 +23,29 @@
 
 namespace {
 
+// The slash that belongs to a reference token is spelled `~1`, and the
+// transformation evaluation applies to a token is alone in turning that back
+// into one, so a token still holding a slash once its octets are decoded
+// conforms to no reference token and is an error condition rather than a
+// member name
+// See https://www.rfc-editor.org/rfc/rfc6901#section-3
+// See https://www.rfc-editor.org/rfc/rfc6901#section-4
+auto append_reference_token(sourcemeta::core::JSON::String &output,
+                            const std::string_view token) -> bool {
+  if (token.find('%') == std::string_view::npos) {
+    output.append(token);
+    return true;
+  }
+
+  const auto decoded{sourcemeta::core::URI::unescape(token)};
+  if (decoded.find('/') != std::string::npos) {
+    return false;
+  }
+
+  output.append(decoded);
+  return true;
+}
+
 template <template <typename T> typename Allocator, typename V,
           typename PointerT = sourcemeta::core::GenericPointer<
               typename V::String,
@@ -336,34 +358,44 @@ auto fragment_to_pointer(const URI &uri) -> std::optional<Pointer> {
     return std::nullopt;
   }
 
+  const auto &value{fragment.value()};
+  if (value.empty()) {
+    return Pointer{};
+  }
+
   // When a URI is dereferenced, the components and subcomponents significant
-  // to the scheme-specific dereferencing process (if any) must be parsed and
-  // separated before the percent-encoded octets within those components can
-  // be safely decoded.
+  // to the dereferencing process must be parsed and separated before the
+  // percent-encoded octets within them can be safely decoded, as the data
+  // would otherwise be mistaken for a delimiter. The only exception is an
+  // octet that stands for an unreserved character, which may be decoded at
+  // any time.
   // See https://www.rfc-editor.org/rfc/rfc3986#section-2.4
-  const auto &value{fragment.value()};
+  //
+  // The slash that precedes every reference token is the delimiter here, and
+  // a reserved character is not equivalent to the octet that stands for it,
+  // so a slash that was percent-encoded never separates two tokens.
+  // See https://www.rfc-editor.org/rfc/rfc3986#section-2.2
+  // See https://www.rfc-editor.org/rfc/rfc6901#section-3
+  if (value.front() != '/') {
+    return std::nullopt;
+  }
+
   JSON::String input;
   input.reserve(value.size());
-  for (std::size_t index = 0; index < value.size(); ++index) {
-    const auto character{value[index]};
-    if (character == '%' && index + 2 < value.size()) {
-      const auto high{sourcemeta::core::hex_digit_value(value[index + 1])};
-      const auto low{sourcemeta::core::hex_digit_value(value[index + 2])};
-      if (high >= 0 && low >= 0) {
-        input.push_back(static_cast<char>((high * 16) + low));
-        index += 2;
-        continue;
-      }
+  auto rest{value.substr(1)};
+  while (true) {
+    const auto parts{split_once(rest, '/')};
+    input.push_back('/');
+    if (!append_reference_token(input,
+                                parts.has_value() ? parts->first : rest)) {
+      return std::nullopt;
     }
 
-    input.push_back(character);
-  }
+    if (!parts.has_value()) {
+      break;
+    }
 
-  if (input.empty()) {
-    return Pointer{};
-  }
-  if (input.front() != '/') {
-    return std::nullopt;
+    rest = parts->second;
   }
 
   try {
diff --git a/vendor/core/src/core/jsonschema/frame.cc b/vendor/core/src/core/jsonschema/frame.cc
index b021aec08..d773866a6 100644
--- a/vendor/core/src/core/jsonschema/frame.cc
+++ b/vendor/core/src/core/jsonschema/frame.cc
@@ -426,7 +426,10 @@ auto locate(const Locations &locations,
 
 // The spelling that every location is framed under and that every reference
 // destination is held to, which is what makes a URI that comes from anywhere
-// else comparable to either of them
+// else comparable to either of them. RFC 3986 Section 6.2.2.2 leaves a
+// percent-encoded reserved character where it stands, and RFC 6901 Section 6
+// only asks for the characters a fragment disallows to be encoded, so one
+// pointer has more than one spelling to begin with
 auto canonicalize_reference(const sourcemeta::core::JSON::String &uri)
     -> std::optional<sourcemeta::core::JSON::String> {
   try {
@@ -439,6 +442,18 @@ auto canonicalize_reference(const sourcemeta::core::JSON::String &uri)
   }
 }
 
+// A lookup that came up empty is only worth repeating under a spelling it has
+// not tried yet
+auto other_spelling(const sourcemeta::core::JSON::String &uri)
+    -> std::optional<sourcemeta::core::JSON::String> {
+  const auto canonical{canonicalize_reference(uri)};
+  if (!canonical.has_value() || canonical.value() == uri) {
+    return std::nullopt;
+  }
+
+  return canonical;
+}
+
 auto set_base_and_fragment(sourcemeta::core::SchemaFrame::Reference &entry)
     -> void {
   const std::string_view destination_view{entry.destination};
@@ -2028,6 +2043,19 @@ auto SchemaFrame::location(const SchemaReferenceType type,
     return result->second;
   }
 
+  // A URI is settled the same way whichever kind of location it is asked
+  // for, as the kind narrows which places answer rather than how the name of
+  // a place is spelled
+  const auto canonical{other_spelling(uri_string)};
+  if (!canonical.has_value()) {
+    return std::nullopt;
+  }
+
+  const auto canonical_result{this->locations_.find({type, canonical.value()})};
+  if (canonical_result != this->locations_.cend()) {
+    return canonical_result->second;
+  }
+
   return std::nullopt;
 }
 
@@ -2122,15 +2150,10 @@ auto SchemaFrame::traverse(const std::string_view uri) const
     return direct;
   }
 
-  // Framing writes every location down under the canonical spelling of its
-  // URI, and holds the destination of every reference to that same spelling,
-  // so one that reaches here spelled any other way names what a reference
-  // spelled identically would reach. RFC 3986 Section 6.2.2.2 leaves a
-  // percent-encoded reserved character where it stands, and RFC 6901 Section
-  // 6 only asks for the characters a fragment disallows to be encoded, so one
-  // pointer has more than one spelling to begin with
-  const auto canonical{canonicalize_reference(uri_string)};
-  if (!canonical.has_value() || canonical.value() == uri_string) {
+  // A URI that reaches here spelled any other way names what a reference
+  // spelled identically would reach
+  const auto canonical{other_spelling(uri_string)};
+  if (!canonical.has_value()) {
     return std::nullopt;
   }
 
diff --git a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_frame.h b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_frame.h
index 13160fdc7..6eca1cd71 100644
--- a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_frame.h
+++ b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_frame.h
@@ -214,7 +214,9 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
             const sourcemeta::core::WeakPointer &pointer) const
       -> std::optional<std::reference_wrapper<const Reference>>;
 
-  /// Get a specific location entry by reference type and URI
+  /// Get a specific location entry by reference type and URI, settling the
+  /// spelling of the URI the way framing settles the one it files a location
+  /// under
   [[nodiscard]] auto location(const SchemaReferenceType type,
                               const std::string_view uri) const
       -> std::optional<std::reference_wrapper<const Location>>;
diff --git a/vendor/jsonbinpack/CMakeLists.txt b/vendor/jsonbinpack/CMakeLists.txt
deleted file mode 100644
index ed273005f..000000000
--- a/vendor/jsonbinpack/CMakeLists.txt
+++ /dev/null
@@ -1,87 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-project(jsonbinpack VERSION 0.0.1 LANGUAGES CXX
-  DESCRIPTION "\
-A space-efficient open-source binary JSON serialization \
-format based on JSON Schema with \
-both schema-driven and schema-less support."
-  HOMEPAGE_URL "https://jsonbinpack.sourcemeta.com")
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
-
-# Options
-option(JSONBINPACK_RUNTIME "Build the JSON BinPack runtime" ON)
-option(JSONBINPACK_COMPILER "Build the JSON BinPack compiler" ON)
-option(JSONBINPACK_TESTS "Build the JSON BinPack tests" OFF)
-option(JSONBINPACK_INSTALL "Install the JSON BinPack library" ON)
-option(JSONBINPACK_DOCS "Build the JSON BinPack documentation" OFF)
-option(JSONBINPACK_ADDRESS_SANITIZER "Build JSON BinPack with an address sanitizer" OFF)
-option(JSONBINPACK_UNDEFINED_SANITIZER "Build JSON BinPack with an undefined behavior sanitizer" OFF)
-
-find_package(Core REQUIRED)
-find_package(Blaze REQUIRED)
-
-if(JSONBINPACK_INSTALL)
-  include(GNUInstallDirs)
-  include(CMakePackageConfigHelpers)
-  configure_package_config_file(
-    config.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
-    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
-  write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
-    COMPATIBILITY SameMajorVersion)
-  install(FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
-    COMPONENT sourcemeta_jsonbinpack_dev)
-endif()
-
-if(JSONBINPACK_ADDRESS_SANITIZER)
-  sourcemeta_sanitizer(TYPE address)
-elseif(JSONBINPACK_UNDEFINED_SANITIZER)
-  sourcemeta_sanitizer(TYPE undefined)
-endif()
-
-# Runtime
-if(JSONBINPACK_RUNTIME)
-  add_subdirectory(src/runtime)
-endif()
-
-# Compiler
-if(JSONBINPACK_COMPILER)
-  add_subdirectory(src/compiler)
-endif()
-
-if(JSONBINPACK_DOCS)
-  sourcemeta_target_doxygen(CONFIG "${PROJECT_SOURCE_DIR}/doxygen/Doxyfile.in"
-    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/www")
-endif()
-
-if(PROJECT_IS_TOP_LEVEL)
-  sourcemeta_target_clang_format(SOURCES
-    src/*.h src/*.cc
-    test/*.h test/*.cc)
-endif()
-
-# Testing
-if(JSONBINPACK_TESTS)
-  enable_testing()
-
-  if(JSONBINPACK_RUNTIME)
-    add_subdirectory(test/runtime)
-  endif()
-
-  if(JSONBINPACK_COMPILER)
-    add_subdirectory(test/compiler)
-  endif()
-
-  add_subdirectory(test/e2e)
-
-  if(PROJECT_IS_TOP_LEVEL)
-    # Otherwise we need the child project to link
-    # against the sanitizers too.
-    if(NOT JSONBINPACK_ADDRESS_SANITIZER AND NOT JSONBINPACK_UNDEFINED_SANITIZER)
-      add_subdirectory(test/packaging)
-    endif()
-  endif()
-endif()
diff --git a/vendor/jsonbinpack/DEPENDENCIES b/vendor/jsonbinpack/DEPENDENCIES
deleted file mode 100644
index 877bcbd7d..000000000
--- a/vendor/jsonbinpack/DEPENDENCIES
+++ /dev/null
@@ -1,4 +0,0 @@
-vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core af2b932ef6284c880f47012749b78bb75526f7a4
-blaze https://github.com/sourcemeta/blaze a5a019aa49139e7cd21accd52ad2c65f66afff16
-bootstrap https://github.com/twbs/bootstrap 1a6fdfae6be09b09eaced8f0e442ca6f7680a61e
diff --git a/vendor/jsonbinpack/LICENSE b/vendor/jsonbinpack/LICENSE
deleted file mode 100644
index 9348973bd..000000000
--- a/vendor/jsonbinpack/LICENSE
+++ /dev/null
@@ -1,12 +0,0 @@
-This software is dual-licensed: you can redistribute it and/or modify it under
-the terms of the GNU Affero General Public License as published by the Free
-Software Foundation, either version 3 of the License, or (at your option) any
-later version. For the terms of this license, see
-<http://www.gnu.org/licenses/>.
-
-You are free to use this software under the terms of the GNU Affero General
-Public License WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-Alternatively, you can use this software under a commercial license, as set out
-in <https://www.sourcemeta.com/licensing/>.
diff --git a/vendor/jsonbinpack/cmake/FindBlaze.cmake b/vendor/jsonbinpack/cmake/FindBlaze.cmake
deleted file mode 100644
index 53fb3fcc3..000000000
--- a/vendor/jsonbinpack/cmake/FindBlaze.cmake
+++ /dev/null
@@ -1,17 +0,0 @@
-if(NOT Blaze_FOUND)
-  if(JSONBINPACK_INSTALL)
-    set(SOURCEMETA_BLAZE_INSTALL ON CACHE BOOL "enable installation")
-  else()
-    set(SOURCEMETA_BLAZE_INSTALL OFF CACHE BOOL "disable installation")
-  endif()
-
-  set(BLAZE_TEST OFF CACHE BOOL "disable")
-  set(BLAZE_CONFIGURATION OFF CACHE BOOL "disable")
-  set(BLAZE_CODEGEN OFF CACHE BOOL "disable")
-  set(BLAZE_DOCUMENTATION OFF CACHE BOOL "disable")
-  set(BLAZE_EDITOR OFF CACHE BOOL "disable")
-  set(BLAZE_CONTRIB OFF CACHE BOOL "disable")
-  add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/blaze")
-  include(Sourcemeta)
-  set(Blaze_FOUND ON)
-endif()
diff --git a/vendor/jsonbinpack/cmake/FindCore.cmake b/vendor/jsonbinpack/cmake/FindCore.cmake
deleted file mode 100644
index 5edb9a990..000000000
--- a/vendor/jsonbinpack/cmake/FindCore.cmake
+++ /dev/null
@@ -1,29 +0,0 @@
-if(NOT Core_FOUND)
-  if(JSONBINPACK_INSTALL)
-    set(SOURCEMETA_CORE_INSTALL ON CACHE BOOL "enable installation")
-  else()
-    set(SOURCEMETA_CORE_INSTALL OFF CACHE BOOL "disable installation")
-  endif()
-
-  if(JSONBINPACK_ADDRESS_SANITIZER OR JSONBINPACK_UNDEFINED_SANITIZER)
-    set(SOURCEMETA_CORE_USE_SYSTEM_ALLOCATOR ON CACHE BOOL "enable the system allocator")
-  else()
-    set(SOURCEMETA_CORE_USE_SYSTEM_ALLOCATOR OFF CACHE BOOL "disable the system allocator")
-  endif()
-
-  set(SOURCEMETA_CORE_LANG_PARALLEL OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_LANG_ERROR OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_JSONL OFF CACHE BOOL "disable JSONL support")
-  set(SOURCEMETA_CORE_JSONRPC OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_MCP OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_HTTP OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_OPENAPI OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_OAUTH OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_OIDC OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_SEMVER OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_MARKDOWN OFF CACHE BOOL "disable")
-  set(SOURCEMETA_CORE_CONTRIB_GOOGLEBENCHMARK OFF CACHE BOOL "GoogleBenchmark")
-  add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/core")
-  include(Sourcemeta)
-  set(Core_FOUND ON)
-endif()
diff --git a/vendor/jsonbinpack/config.cmake.in b/vendor/jsonbinpack/config.cmake.in
deleted file mode 100644
index 0f05b050e..000000000
--- a/vendor/jsonbinpack/config.cmake.in
+++ /dev/null
@@ -1,25 +0,0 @@
-@PACKAGE_INIT@
-
-# Support both casing styles
-list(APPEND JSONBINPACK_COMPONENTS ${JSONBinPack_FIND_COMPONENTS})
-list(APPEND JSONBINPACK_COMPONENTS ${jsonbinpack_FIND_COMPONENTS})
-if(NOT JSONBINPACK_COMPONENTS)
-  list(APPEND JSONBINPACK_COMPONENTS runtime)
-  list(APPEND JSONBINPACK_COMPONENTS compiler)
-endif()
-
-include(CMakeFindDependencyMacro)
-find_dependency(Core COMPONENTS json uri jsonpointer jsonschema numeric regex io)
-find_dependency(Blaze COMPONENTS alterschema canonicalizer)
-
-foreach(component ${JSONBINPACK_COMPONENTS})
-  if(component STREQUAL "runtime")
-    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_jsonbinpack_runtime.cmake")
-  elseif(component STREQUAL "compiler")
-    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_jsonbinpack_compiler.cmake")
-  else()
-    message(FATAL_ERROR "Unknown JSON BinPack component: ${component}")
-  endif()
-endforeach()
-
-check_required_components("@PROJECT_NAME@")
diff --git a/vendor/jsonbinpack/src/compiler/CMakeLists.txt b/vendor/jsonbinpack/src/compiler/CMakeLists.txt
deleted file mode 100644
index d3fccac22..000000000
--- a/vendor/jsonbinpack/src/compiler/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-sourcemeta_library(NAMESPACE sourcemeta PROJECT jsonbinpack NAME compiler
-  FOLDER "JSON BinPack/Compiler"
-  SOURCES
-    encoding.h compiler.cc
-    mapper/enum_8_bit.h
-    mapper/enum_8_bit_top_level.h
-    mapper/enum_arbitrary.h
-    mapper/enum_singleton.h
-    mapper/integer_bounded_8_bit.h
-    mapper/integer_bounded_greater_than_8_bit.h
-    mapper/integer_bounded_multiplier_8_bit.h
-    mapper/integer_bounded_multiplier_greater_than_8_bit.h
-    mapper/integer_lower_bound.h
-    mapper/integer_lower_bound_multiplier.h
-    mapper/integer_unbound.h
-    mapper/integer_unbound_multiplier.h
-    mapper/integer_upper_bound.h
-    mapper/integer_upper_bound_multiplier.h
-    mapper/number_arbitrary.h)
-
-if(JSONBINPACK_INSTALL)
-  sourcemeta_library_install(NAMESPACE sourcemeta PROJECT jsonbinpack NAME compiler)
-endif()
-
-target_link_libraries(sourcemeta_jsonbinpack_compiler PRIVATE
-  sourcemeta::core::numeric)
-target_link_libraries(sourcemeta_jsonbinpack_compiler PUBLIC
-  sourcemeta::core::json)
-target_link_libraries(sourcemeta_jsonbinpack_compiler PRIVATE
-  sourcemeta::core::jsonpointer)
-target_link_libraries(sourcemeta_jsonbinpack_compiler PUBLIC
-  sourcemeta::core::jsonschema)
-target_link_libraries(sourcemeta_jsonbinpack_compiler PRIVATE
-  sourcemeta::blaze::alterschema)
-target_link_libraries(sourcemeta_jsonbinpack_compiler PRIVATE
-  sourcemeta::blaze::canonicalizer)
diff --git a/vendor/jsonbinpack/src/compiler/compiler.cc b/vendor/jsonbinpack/src/compiler/compiler.cc
deleted file mode 100644
index 4b2ff06c0..000000000
--- a/vendor/jsonbinpack/src/compiler/compiler.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-#include <sourcemeta/jsonbinpack/compiler.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <sourcemeta/blaze/alterschema.h>
-#include <sourcemeta/blaze/canonicalizer.h>
-#include <sourcemeta/core/jsonpointer.h>
-
-#include "encoding.h"
-
-#include <cassert>     // assert
-#include <type_traits> // std::true_type
-
-static auto transformer_callback_noop(
-    [[maybe_unused]] const sourcemeta::core::Pointer &pointer,
-    [[maybe_unused]] const std::string_view name,
-    [[maybe_unused]] const std::string_view message,
-    [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-        &result,
-    [[maybe_unused]] const bool applied) -> void {
-  assert(applied);
-}
-
-namespace sourcemeta::jsonbinpack {
-
-auto canonicalize(sourcemeta::core::JSON &schema,
-                  const sourcemeta::core::SchemaWalker &walker,
-                  const sourcemeta::core::SchemaResolver &resolver,
-                  const std::string_view default_dialect) -> void {
-  sourcemeta::blaze::canonicalize(schema, walker, make_resolver(resolver),
-                                  default_dialect);
-}
-
-auto make_encoding(sourcemeta::core::JSON &document,
-                   const std::string &encoding,
-                   const sourcemeta::core::JSON &options) -> void {
-  document.into_object();
-  document.assign("$schema", sourcemeta::core::JSON{ENCODING_V1});
-  document.assign("binpackEncoding", sourcemeta::core::JSON{encoding});
-  document.assign("binpackOptions", options);
-}
-
-#include "mapper/enum_8_bit.h"
-#include "mapper/enum_8_bit_top_level.h"
-#include "mapper/enum_arbitrary.h"
-#include "mapper/enum_singleton.h"
-#include "mapper/integer_bounded_8_bit.h"
-#include "mapper/integer_bounded_greater_than_8_bit.h"
-#include "mapper/integer_bounded_multiplier_8_bit.h"
-#include "mapper/integer_bounded_multiplier_greater_than_8_bit.h"
-#include "mapper/integer_lower_bound.h"
-#include "mapper/integer_lower_bound_multiplier.h"
-#include "mapper/integer_unbound.h"
-#include "mapper/integer_unbound_multiplier.h"
-#include "mapper/integer_upper_bound.h"
-#include "mapper/integer_upper_bound_multiplier.h"
-#include "mapper/number_arbitrary.h"
-
-auto compile(sourcemeta::core::JSON &schema,
-             const sourcemeta::core::SchemaWalker &walker,
-             const sourcemeta::core::SchemaResolver &resolver,
-             const std::string_view default_dialect) -> void {
-  sourcemeta::jsonbinpack::canonicalize(schema, walker, resolver,
-                                        default_dialect);
-
-  sourcemeta::blaze::SchemaTransformer mapper;
-
-  // Enums
-  mapper.add<Enum8Bit>();
-  mapper.add<Enum8BitTopLevel>();
-  mapper.add<EnumArbitrary>();
-  mapper.add<EnumSingleton>();
-
-  // Integers
-  mapper.add<IntegerBounded8Bit>();
-  mapper.add<IntegerBoundedMultiplier8Bit>();
-  mapper.add<IntegerBoundedGreaterThan8Bit>();
-  mapper.add<IntegerBoundedMultiplierGreaterThan8Bit>();
-  mapper.add<IntegerLowerBound>();
-  mapper.add<IntegerLowerBoundMultiplier>();
-  mapper.add<IntegerUpperBound>();
-  mapper.add<IntegerUpperBoundMultiplier>();
-  mapper.add<IntegerUnbound>();
-  mapper.add<IntegerUnboundMultiplier>();
-
-  // Numbers
-  mapper.add<NumberArbitrary>();
-
-  [[maybe_unused]] const auto mapper_result =
-      mapper.apply(schema, walker, make_resolver(resolver),
-                   transformer_callback_noop, default_dialect);
-  assert(mapper_result.first);
-
-  // The "any" encoding is always the last resort
-  const auto *declared{schema.is_object() ? schema.try_at("$schema") : nullptr};
-  const auto dialect{declared != nullptr && declared->is_string()
-                         ? declared->to_string()
-                         : std::string_view{}};
-  if (dialect.empty() || dialect != ENCODING_V1) {
-    make_encoding(schema, "ANY_PACKED_TYPE_TAG_BYTE_PREFIX",
-                  sourcemeta::core::JSON::make_object());
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/compiler/encoding.h b/vendor/jsonbinpack/src/compiler/encoding.h
deleted file mode 100644
index 5257b4888..000000000
--- a/vendor/jsonbinpack/src/compiler/encoding.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_COMPILER_ENCODING_H_
-#define SOURCEMETA_JSONBINPACK_COMPILER_ENCODING_H_
-
-#include <sourcemeta/core/json.h>
-#include <sourcemeta/core/jsonschema.h>
-
-namespace sourcemeta::jsonbinpack {
-
-constexpr auto ENCODING_V1{"tag:sourcemeta.com,2024:jsonbinpack/encoding/v1"};
-
-inline auto make_resolver(const sourcemeta::core::SchemaResolver &fallback)
-    -> auto {
-  return [&fallback](std::string_view identifier)
-             -> sourcemeta::core::SchemaResolverResult {
-    if (identifier == ENCODING_V1) {
-      static const auto SCHEMA{sourcemeta::core::parse_json(R"JSON({
-        "$id": "tag:sourcemeta.com,2024:jsonbinpack/encoding/v1",
-        "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "$vocabulary": {
-          "https://json-schema.org/draft/2020-12/vocab/core": true,
-          "tag:sourcemeta.com,2024:jsonbinpack/encoding/v1": true
-        }
-      })JSON")};
-      return SCHEMA;
-    }
-
-    return fallback(identifier);
-  };
-}
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/compiler/include/sourcemeta/jsonbinpack/compiler.h b/vendor/jsonbinpack/src/compiler/include/sourcemeta/jsonbinpack/compiler.h
deleted file mode 100644
index c1ec85a9d..000000000
--- a/vendor/jsonbinpack/src/compiler/include/sourcemeta/jsonbinpack/compiler.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_COMPILER_H_
-#define SOURCEMETA_JSONBINPACK_COMPILER_H_
-
-#ifndef SOURCEMETA_JSONBINPACK_COMPILER_EXPORT
-#include <sourcemeta/jsonbinpack/compiler_export.h>
-#endif
-
-/// @defgroup compiler Compiler
-/// @brief The built-time schema compiler of JSON BinPack
-///
-/// This functionality is included as follows:
-///
-/// ```cpp
-/// #include <sourcemeta/jsonbinpack/compiler.h>
-/// ```
-
-#include <sourcemeta/core/json.h>
-#include <sourcemeta/core/jsonschema.h>
-
-#include <string_view> // std::string_view
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup compiler
-///
-/// Compile a JSON Schema into an encoding schema. Keep in mind this function
-/// mutates the input schema. For example:
-///
-/// ```cpp
-/// #include <sourcemeta/binpack/compiler.h>
-/// #include <sourcemeta/core/json.h>
-/// #include <sourcemeta/core/jsonschema.h>
-///
-/// #include <iostream>
-///
-/// auto schema{sourcemeta::core::parse_json(R"JSON({
-///   "$schema": "https://json-schema.org/draft/2020-12/schema",
-///   "type": "string"
-/// })JSON")};
-///
-/// sourcemeta::jsonbinpack::compile(
-///     schema, sourcemeta::core::schema_walker,
-///     sourcemeta::core::schema_resolver);
-///
-/// sourcemeta::core::prettify(schema, std::cout);
-/// std::cout << std::endl;
-/// ```
-SOURCEMETA_JSONBINPACK_COMPILER_EXPORT
-auto compile(sourcemeta::core::JSON &schema,
-             const sourcemeta::core::SchemaWalker &walker,
-             const sourcemeta::core::SchemaResolver &resolver,
-             std::string_view default_dialect = "") -> void;
-
-/// @ingroup compiler
-///
-/// Transform a JSON Schema into its canonical form to prepare it for
-/// compilation. Keep in mind this function mutates the input schema. Also, the
-/// `compile` function already performs canonicalization. This function is
-/// exposed mainly for debugging and testing purposes. For example:
-///
-/// ```cpp
-/// #include <sourcemeta/binpack/compiler.h>
-/// #include <sourcemeta/core/json.h>
-/// #include <sourcemeta/core/jsonschema.h>
-///
-/// #include <iostream>
-///
-/// auto schema{sourcemeta::core::parse_json(R"JSON({
-///   "$schema": "https://json-schema.org/draft/2020-12/schema",
-///   "type": "string"
-/// })JSON")};
-///
-/// sourcemeta::jsonbinpack::canonicalize(
-///     schema, sourcemeta::core::schema_walker,
-///     sourcemeta::core::schema_resolver);
-///
-/// sourcemeta::core::prettify(schema, std::cout);
-/// std::cout << std::endl;
-/// ```
-SOURCEMETA_JSONBINPACK_COMPILER_EXPORT
-auto canonicalize(sourcemeta::core::JSON &schema,
-                  const sourcemeta::core::SchemaWalker &walker,
-                  const sourcemeta::core::SchemaResolver &resolver,
-                  std::string_view default_dialect = "") -> void;
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit.h b/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit.h
deleted file mode 100644
index f5c6032e3..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// TODO: Unit test this mapping once we have container encodings
-class Enum8Bit final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  Enum8Bit() : sourcemeta::blaze::SchemaTransformRule{"enum_8_bit", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("enum") &&
-           schema.at("enum").is_array() && !location.pointer.empty() &&
-           schema.at("enum").size() > 1 &&
-           sourcemeta::core::is_byte(schema.at("enum").size() - 1);
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", schema.at("enum"));
-    make_encoding(schema, "BYTE_CHOICE_INDEX", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit_top_level.h b/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit_top_level.h
deleted file mode 100644
index 7810e8f4c..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/enum_8_bit_top_level.h
+++ /dev/null
@@ -1,34 +0,0 @@
-class Enum8BitTopLevel final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  Enum8BitTopLevel()
-      : sourcemeta::blaze::SchemaTransformRule{"enum_8_bit_top_level", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("enum") &&
-           schema.at("enum").is_array() && location.pointer.empty() &&
-           schema.at("enum").size() > 1 &&
-           sourcemeta::core::is_byte(schema.at("enum").size() - 1);
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", schema.at("enum"));
-    make_encoding(schema, "TOP_LEVEL_BYTE_CHOICE_INDEX", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/enum_arbitrary.h b/vendor/jsonbinpack/src/compiler/mapper/enum_arbitrary.h
deleted file mode 100644
index 34b4b5a90..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/enum_arbitrary.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// TODO: Unit test this mapping once we have container encodings
-class EnumArbitrary final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  EnumArbitrary()
-      : sourcemeta::blaze::SchemaTransformRule{"enum_arbitrary", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("enum") &&
-           schema.at("enum").is_array() && !location.pointer.empty() &&
-           schema.at("enum").size() > 1 &&
-           !sourcemeta::core::is_byte(schema.at("enum").size() - 1);
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("choices", schema.at("enum"));
-    make_encoding(schema, "LARGE_CHOICE_INDEX", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/enum_singleton.h b/vendor/jsonbinpack/src/compiler/mapper/enum_singleton.h
deleted file mode 100644
index bc61d34d9..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/enum_singleton.h
+++ /dev/null
@@ -1,32 +0,0 @@
-class EnumSingleton final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  EnumSingleton()
-      : sourcemeta::blaze::SchemaTransformRule{"enum_singleton", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("enum") &&
-           schema.at("enum").is_array() && schema.at("enum").size() == 1;
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("value", schema.at("enum").at(0));
-    make_encoding(schema, "CONST_NONE", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_8_bit.h b/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_8_bit.h
deleted file mode 100644
index c9661da6d..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_8_bit.h
+++ /dev/null
@@ -1,40 +0,0 @@
-class IntegerBounded8Bit final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerBounded8Bit()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_bounded_8_bit", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("minimum") && schema.defines("maximum") &&
-           sourcemeta::core::is_byte(schema.at("maximum").to_integer() -
-                                     schema.at("minimum").to_integer()) &&
-           !schema.defines("multipleOf");
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto maximum = schema.at("maximum");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("maximum", std::move(maximum));
-    options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(schema, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_greater_than_8_bit.h b/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_greater_than_8_bit.h
deleted file mode 100644
index 85f8fe652..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_greater_than_8_bit.h
+++ /dev/null
@@ -1,40 +0,0 @@
-class IntegerBoundedGreaterThan8Bit final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerBoundedGreaterThan8Bit()
-      : sourcemeta::blaze::SchemaTransformRule{
-            "integer_bounded_greater_than_8_bit", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("minimum") && schema.defines("maximum") &&
-           !sourcemeta::core::is_byte(schema.at("maximum").to_integer() -
-                                      schema.at("minimum").to_integer()) &&
-           !schema.defines("multipleOf");
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_8_bit.h b/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_8_bit.h
deleted file mode 100644
index 29414f411..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_8_bit.h
+++ /dev/null
@@ -1,50 +0,0 @@
-class IntegerBoundedMultiplier8Bit final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerBoundedMultiplier8Bit()
-      : sourcemeta::blaze::SchemaTransformRule{
-            "integer_bounded_multiplier_8_bit", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    if (location.dialect != "https://json-schema.org/draft/2020-12/schema" ||
-        !vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                   JSON_SCHEMA_2020_12_VALIDATION) ||
-        !schema.is_object() || !schema.defines("type") ||
-        schema.at("type").to_string() != "integer" ||
-        !schema.defines("minimum") || !schema.at("minimum").is_integer() ||
-        !schema.defines("maximum") || !schema.at("maximum").is_integer() ||
-        !schema.defines("multipleOf") ||
-        !schema.at("multipleOf").is_integer()) {
-      return false;
-    }
-
-    return sourcemeta::core::is_byte(sourcemeta::core::count_multiples(
-        schema.at("minimum").to_integer(), schema.at("maximum").to_integer(),
-        schema.at("multipleOf").to_integer()));
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto maximum = schema.at("maximum");
-    auto multiplier = schema.at("multipleOf");
-
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("maximum", std::move(maximum));
-    options.assign("multiplier", std::move(multiplier));
-    make_encoding(schema, "BOUNDED_MULTIPLE_8BITS_ENUM_FIXED", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h b/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h
deleted file mode 100644
index 267399c41..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h
+++ /dev/null
@@ -1,47 +0,0 @@
-class IntegerBoundedMultiplierGreaterThan8Bit final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerBoundedMultiplierGreaterThan8Bit()
-      : sourcemeta::blaze::SchemaTransformRule{
-            "integer_bounded_multiplier_greater_than_8_bit", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    if (location.dialect != "https://json-schema.org/draft/2020-12/schema" ||
-        !vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                   JSON_SCHEMA_2020_12_VALIDATION) ||
-        !schema.is_object() || !schema.defines("type") ||
-        schema.at("type").to_string() != "integer" ||
-        !schema.defines("minimum") || !schema.at("minimum").is_integer() ||
-        !schema.defines("maximum") || !schema.at("maximum").is_integer() ||
-        !schema.defines("multipleOf") ||
-        !schema.at("multipleOf").is_integer()) {
-      return false;
-    }
-
-    return !sourcemeta::core::is_byte(sourcemeta::core::count_multiples(
-        schema.at("minimum").to_integer(), schema.at("maximum").to_integer(),
-        schema.at("multipleOf").to_integer()));
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto multiplier = schema.at("multipleOf");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("multiplier", std::move(multiplier));
-    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound.h b/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound.h
deleted file mode 100644
index d9a68ff30..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound.h
+++ /dev/null
@@ -1,36 +0,0 @@
-class IntegerLowerBound final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerLowerBound()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_lower_bound", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("minimum") && !schema.defines("maximum") &&
-           !schema.defines("multipleOf");
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound_multiplier.h b/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound_multiplier.h
deleted file mode 100644
index e0a1195c8..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_lower_bound_multiplier.h
+++ /dev/null
@@ -1,39 +0,0 @@
-class IntegerLowerBoundMultiplier final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerLowerBoundMultiplier()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_lower_bound_multiplier",
-                                               ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("minimum") && !schema.defines("maximum") &&
-           schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto minimum = schema.at("minimum");
-    auto multiplier = schema.at("multipleOf");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("minimum", std::move(minimum));
-    options.assign("multiplier", std::move(multiplier));
-    make_encoding(schema, "FLOOR_MULTIPLE_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_unbound.h b/vendor/jsonbinpack/src/compiler/mapper/integer_unbound.h
deleted file mode 100644
index 506df0bd8..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_unbound.h
+++ /dev/null
@@ -1,34 +0,0 @@
-class IntegerUnbound final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerUnbound()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_unbound", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           !schema.defines("minimum") && !schema.defines("maximum") &&
-           !schema.defines("multipleOf");
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(schema, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_unbound_multiplier.h b/vendor/jsonbinpack/src/compiler/mapper/integer_unbound_multiplier.h
deleted file mode 100644
index 2e839fde9..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_unbound_multiplier.h
+++ /dev/null
@@ -1,37 +0,0 @@
-class IntegerUnboundMultiplier final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerUnboundMultiplier()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_unbound_multiplier",
-                                               ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           !schema.defines("minimum") && !schema.defines("maximum") &&
-           schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto multiplier = schema.at("multipleOf");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("multiplier", std::move(multiplier));
-    make_encoding(schema, "ARBITRARY_MULTIPLE_ZIGZAG_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound.h b/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound.h
deleted file mode 100644
index c6b4009d1..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound.h
+++ /dev/null
@@ -1,36 +0,0 @@
-class IntegerUpperBound final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerUpperBound()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_upper_bound", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           !schema.defines("minimum") && schema.defines("maximum") &&
-           !schema.defines("multipleOf");
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto maximum = schema.at("maximum");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("maximum", std::move(maximum));
-    options.assign("multiplier", sourcemeta::core::JSON{1});
-    make_encoding(schema, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound_multiplier.h b/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound_multiplier.h
deleted file mode 100644
index 404e2b0ac..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/integer_upper_bound_multiplier.h
+++ /dev/null
@@ -1,39 +0,0 @@
-class IntegerUpperBoundMultiplier final
-    : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  IntegerUpperBoundMultiplier()
-      : sourcemeta::blaze::SchemaTransformRule{"integer_upper_bound_multiplier",
-                                               ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "integer" &&
-           !schema.defines("minimum") && schema.defines("maximum") &&
-           schema.defines("multipleOf") && schema.at("multipleOf").is_integer();
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    auto maximum = schema.at("maximum");
-    auto multiplier = schema.at("multipleOf");
-    auto options = sourcemeta::core::JSON::make_object();
-    options.assign("maximum", std::move(maximum));
-    options.assign("multiplier", std::move(multiplier));
-    make_encoding(schema, "ROOF_MULTIPLE_MIRROR_ENUM_VARINT", options);
-  }
-};
diff --git a/vendor/jsonbinpack/src/compiler/mapper/number_arbitrary.h b/vendor/jsonbinpack/src/compiler/mapper/number_arbitrary.h
deleted file mode 100644
index eb76f5a60..000000000
--- a/vendor/jsonbinpack/src/compiler/mapper/number_arbitrary.h
+++ /dev/null
@@ -1,31 +0,0 @@
-class NumberArbitrary final : public sourcemeta::blaze::SchemaTransformRule {
-public:
-  using mutates = std::true_type;
-  using reframe_after_transform = std::true_type;
-  NumberArbitrary()
-      : sourcemeta::blaze::SchemaTransformRule{"number_arbitrary", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
-      -> sourcemeta::blaze::SchemaTransformRule::Result override {
-    return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
-           vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
-                                     JSON_SCHEMA_2020_12_VALIDATION) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").to_string() == "number";
-  }
-
-  auto transform(
-      sourcemeta::core::JSON &schema,
-      [[maybe_unused]] const sourcemeta::blaze::SchemaTransformRule::Result
-          &result) const -> void override {
-    make_encoding(schema, "NUMBER_VARINT_TUPLE",
-                  sourcemeta::core::JSON::make_object());
-  }
-};
diff --git a/vendor/jsonbinpack/src/runtime/CMakeLists.txt b/vendor/jsonbinpack/src/runtime/CMakeLists.txt
deleted file mode 100644
index 94dd8e1ca..000000000
--- a/vendor/jsonbinpack/src/runtime/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-sourcemeta_library(NAMESPACE sourcemeta PROJECT jsonbinpack NAME runtime
-  FOLDER "JSON BinPack/Runtime"
-  PRIVATE_HEADERS
-    decoder.h
-    encoder.h
-    input_stream.h
-    output_stream.h
-    encoder_cache.h
-    encoding.h
-  SOURCES
-    input_stream.cc
-    output_stream.cc
-    unreachable.h
-    cache.cc
-
-    loader.cc
-    loader_v1_any.h
-    loader_v1_array.h
-    loader_v1_integer.h
-    loader_v1_number.h
-    loader_v1_string.h
-
-    decoder_any.cc
-    decoder_array.cc
-    decoder_common.cc
-    decoder_integer.cc
-    decoder_number.cc
-    decoder_object.cc
-    decoder_string.cc
-    encoder_any.cc
-    encoder_array.cc
-    encoder_common.cc
-    encoder_integer.cc
-    encoder_number.cc
-    encoder_object.cc
-    encoder_string.cc)
-
-if(JSONBINPACK_INSTALL)
-  sourcemeta_library_install(NAMESPACE sourcemeta PROJECT jsonbinpack NAME runtime)
-endif()
-
-target_link_libraries(sourcemeta_jsonbinpack_runtime PUBLIC
-  sourcemeta::core::json)
-target_link_libraries(sourcemeta_jsonbinpack_runtime PUBLIC
-  sourcemeta::core::numeric)
-target_link_libraries(sourcemeta_jsonbinpack_runtime PUBLIC
-  sourcemeta::core::io)
diff --git a/vendor/jsonbinpack/src/runtime/cache.cc b/vendor/jsonbinpack/src/runtime/cache.cc
deleted file mode 100644
index def0ee80f..000000000
--- a/vendor/jsonbinpack/src/runtime/cache.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder_cache.h>
-
-namespace sourcemeta::jsonbinpack {
-
-auto Cache::record(const sourcemeta::core::JSON::String &value,
-                   const std::uint64_t offset, const Type type) -> void {
-  // Encoding a shared string has some overhead, such as the
-  // shared string marker + the offset, so its not worth
-  // doing for strings that are too small.
-  constexpr auto MINIMUM_STRING_LENGTH{3};
-
-  // We don't want to allow the context to grow
-  // forever, otherwise an attacker could force the
-  // program to exhaust memory given an input
-  // document that contains a high number of large strings.
-  constexpr auto MAXIMUM_BYTE_SIZE{20971520};
-
-  const auto value_size{value.size()};
-  if (value_size < MINIMUM_STRING_LENGTH || value_size >= MAXIMUM_BYTE_SIZE) {
-    return;
-  }
-
-  // Remove the oldest entries to make space if needed
-  while (!this->data_.empty() &&
-         this->byte_size_ + value_size >= MAXIMUM_BYTE_SIZE) {
-    this->remove_oldest();
-  }
-
-  auto result{this->data_.insert({std::make_pair(value, type), offset})};
-  if (result.second) {
-    this->byte_size_ += value_size;
-    this->order_.emplace(offset, result.first->first);
-  } else if (offset > result.first->second) {
-    this->order_.erase(result.first->second);
-    // If the string already exists, we want to
-    // bump the offset for locality purposes.
-    result.first->second = offset;
-    this->order_.emplace(offset, result.first->first);
-  }
-
-  // Otherwise we are doing something wrong
-  assert(this->order_.size() == this->data_.size());
-}
-
-auto Cache::remove_oldest() -> void {
-  assert(!this->data_.empty());
-  // std::map are by definition ordered by key,
-  // so the begin iterator points to the entry
-  // with the lowest offset, a.k.a. the oldest.
-  const auto iterator{this->order_.cbegin()};
-  this->byte_size_ -= iterator->second.get().first.size();
-  this->data_.erase(iterator->second.get());
-  this->order_.erase(iterator);
-}
-
-auto Cache::find(const sourcemeta::core::JSON::String &value,
-                 const Type type) const -> std::optional<std::uint64_t> {
-  const auto result{this->data_.find(std::make_pair(value, type))};
-  if (result == this->data_.cend()) {
-    return std::nullopt;
-  }
-
-  return result->second;
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_any.cc b/vendor/jsonbinpack/src/runtime/decoder_any.cc
deleted file mode 100644
index 4c0fa9c0a..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_any.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include "unreachable.h"
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint16_t, std::uint64_t
-#include <memory>  // std::make_shared
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::BYTE_CHOICE_INDEX(const struct BYTE_CHOICE_INDEX &options)
-    -> sourcemeta::core::JSON {
-  assert(!options.choices.empty());
-  assert(sourcemeta::core::is_byte(options.choices.size()));
-  const std::uint8_t index{this->get_byte()};
-  assert(options.choices.size() > index);
-  return options.choices[index];
-}
-
-auto Decoder::LARGE_CHOICE_INDEX(const struct LARGE_CHOICE_INDEX &options)
-    -> sourcemeta::core::JSON {
-  assert(!options.choices.empty());
-  const std::uint64_t index{this->get_varint()};
-  assert(options.choices.size() > index);
-  return options.choices[index];
-}
-
-auto Decoder::TOP_LEVEL_BYTE_CHOICE_INDEX(
-    const struct TOP_LEVEL_BYTE_CHOICE_INDEX &options)
-    -> sourcemeta::core::JSON {
-  assert(!options.choices.empty());
-  assert(sourcemeta::core::is_byte(options.choices.size()));
-  if (!this->has_more_data()) {
-    return options.choices.front();
-  }
-
-  const std::uint16_t index{static_cast<std::uint16_t>(this->get_byte() + 1)};
-  assert(options.choices.size() > index);
-  return options.choices[index];
-}
-
-auto Decoder::CONST_NONE(const struct CONST_NONE &options)
-    -> sourcemeta::core::JSON {
-  return options.value;
-}
-
-auto Decoder::ANY_PACKED_TYPE_TAG_BYTE_PREFIX(
-    [[maybe_unused]] const struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX &options)
-    -> sourcemeta::core::JSON {
-  using namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX;
-  const std::uint8_t byte{this->get_byte()};
-  const std::uint8_t type{
-      static_cast<std::uint8_t>(byte & (0xff >> SUBTYPE_SIZE))};
-  const std::uint8_t subtype{static_cast<std::uint8_t>(byte >> TYPE_SIZE)};
-
-  if (type == TYPE_OTHER) {
-    switch (subtype) {
-      case SUBTYPE_NULL:
-        return sourcemeta::core::JSON{nullptr};
-      case SUBTYPE_FALSE:
-        return sourcemeta::core::JSON{false};
-      case SUBTYPE_TRUE:
-        return sourcemeta::core::JSON{true};
-      case SUBTYPE_NUMBER:
-        return this->DOUBLE_VARINT_TUPLE({});
-      case SUBTYPE_DECIMAL:
-        return this->NUMBER_VARINT_TUPLE({});
-      case SUBTYPE_POSITIVE_REAL_INTEGER_BYTE:
-        return sourcemeta::core::JSON{static_cast<double>(this->get_byte())};
-      case SUBTYPE_POSITIVE_INTEGER:
-        return sourcemeta::core::JSON{
-            static_cast<std::int64_t>(this->get_varint())};
-      case SUBTYPE_NEGATIVE_INTEGER:
-        return sourcemeta::core::JSON{
-            -static_cast<std::int64_t>(this->get_varint()) - 1};
-      case SUBTYPE_LONG_STRING_BASE_EXPONENT_7:
-        return sourcemeta::core::JSON{
-            this->get_string_utf8(this->get_varint() + 128)};
-      case SUBTYPE_LONG_STRING_BASE_EXPONENT_8:
-        return sourcemeta::core::JSON{
-            this->get_string_utf8(this->get_varint() + 256)};
-      case SUBTYPE_LONG_STRING_BASE_EXPONENT_9:
-        return sourcemeta::core::JSON{
-            this->get_string_utf8(this->get_varint() + 512)};
-      case SUBTYPE_LONG_STRING_BASE_EXPONENT_10:
-        return sourcemeta::core::JSON{
-            this->get_string_utf8(this->get_varint() + 1024)};
-      default:
-        unreachable();
-    }
-  } else {
-    switch (type) {
-      case TYPE_POSITIVE_INTEGER_BYTE:
-        return sourcemeta::core::JSON{subtype > 0 ? subtype - 1
-                                                  : this->get_byte()};
-      case TYPE_NEGATIVE_INTEGER_BYTE:
-        return sourcemeta::core::JSON{
-            subtype > 0 ? static_cast<std::int64_t>(-subtype)
-                        : static_cast<std::int64_t>(-this->get_byte() - 1)};
-      case TYPE_SHARED_STRING: {
-        const auto length = subtype == 0
-                                ? this->get_varint() - 1 +
-                                      (static_cast<std::uint64_t>(
-                                           sourcemeta::core::uint_max<5>) *
-                                       2)
-                                : subtype - 1;
-        const std::uint64_t position{this->position()};
-        const std::uint64_t current{this->rewind(this->get_varint(), position)};
-        const sourcemeta::core::JSON value{this->get_string_utf8(length)};
-        this->seek(current);
-        return value;
-      };
-      case TYPE_STRING:
-        return subtype == 0
-                   ? this->FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED(
-                         {static_cast<std::uint64_t>(
-                              sourcemeta::core::uint_max<5>) *
-                          2})
-                   : sourcemeta::core::JSON{this->get_string_utf8(subtype - 1)};
-      case TYPE_LONG_STRING:
-        return sourcemeta::core::JSON{
-            this->get_string_utf8(subtype + sourcemeta::core::uint_max<5>)};
-      case TYPE_ARRAY:
-        return subtype == 0
-                   ? this->FIXED_TYPED_ARRAY(
-                         {.size = this->get_varint() +
-                                  sourcemeta::core::uint_max<5>,
-                          .encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  ANY_PACKED_TYPE_TAG_BYTE_PREFIX{}),
-                          .prefix_encodings = {}})
-                   : this->FIXED_TYPED_ARRAY(
-                         {.size = static_cast<std::uint64_t>(subtype - 1),
-                          .encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  ANY_PACKED_TYPE_TAG_BYTE_PREFIX{}),
-                          .prefix_encodings = {}});
-      case TYPE_OBJECT:
-        return subtype == 0
-                   ? this->FIXED_TYPED_ARBITRARY_OBJECT(
-                         {.size = this->get_varint() +
-                                  sourcemeta::core::uint_max<5>,
-                          .key_encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  PREFIX_VARINT_LENGTH_STRING_SHARED{}),
-                          .encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  ANY_PACKED_TYPE_TAG_BYTE_PREFIX{})})
-                   : this->FIXED_TYPED_ARBITRARY_OBJECT(
-                         {.size = static_cast<std::uint64_t>(subtype - 1),
-                          .key_encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  PREFIX_VARINT_LENGTH_STRING_SHARED{}),
-                          .encoding = std::make_shared<Encoding>(
-                              sourcemeta::jsonbinpack::
-                                  ANY_PACKED_TYPE_TAG_BYTE_PREFIX{})});
-      default:
-        unreachable();
-    }
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_array.cc b/vendor/jsonbinpack/src/runtime/decoder_array.cc
deleted file mode 100644
index 0d5f1c3cc..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_array.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint64_t
-#include <utility> // std::move
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::FIXED_TYPED_ARRAY(const struct FIXED_TYPED_ARRAY &options)
-    -> sourcemeta::core::JSON {
-  const auto prefix_encodings{options.prefix_encodings.size()};
-  sourcemeta::core::JSON result = sourcemeta::core::JSON::make_array();
-  for (std::size_t index = 0; index < options.size; index++) {
-    const Encoding &encoding{prefix_encodings > index
-                                 ? options.prefix_encodings[index]
-                                 : *(options.encoding)};
-    result.push_back(this->read(encoding));
-  }
-
-  assert(result.size() == options.size);
-  return result;
-};
-
-auto Decoder::BOUNDED_8BITS_TYPED_ARRAY(
-    const struct BOUNDED_8BITS_TYPED_ARRAY &options) -> sourcemeta::core::JSON {
-  assert(options.maximum >= options.minimum);
-  assert(sourcemeta::core::is_byte(options.maximum - options.minimum));
-  const std::uint8_t byte{this->get_byte()};
-  const std::uint64_t size{byte + options.minimum};
-  assert(sourcemeta::core::is_within(size, options.minimum, options.maximum));
-  return this->FIXED_TYPED_ARRAY(
-      {.size = size,
-       .encoding = options.encoding,
-       .prefix_encodings = options.prefix_encodings});
-};
-
-auto Decoder::FLOOR_TYPED_ARRAY(const struct FLOOR_TYPED_ARRAY &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t value{this->get_varint()};
-  const std::uint64_t size{value + options.minimum};
-  assert(size >= value);
-  assert(size >= options.minimum);
-  return this->FIXED_TYPED_ARRAY(
-      {.size = size,
-       .encoding = options.encoding,
-       .prefix_encodings = options.prefix_encodings});
-};
-
-auto Decoder::ROOF_TYPED_ARRAY(const struct ROOF_TYPED_ARRAY &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t value{this->get_varint()};
-  const std::uint64_t size{options.maximum - value};
-  assert(size <= options.maximum);
-  return this->FIXED_TYPED_ARRAY(
-      {.size = size,
-       .encoding = options.encoding,
-       .prefix_encodings = options.prefix_encodings});
-};
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_common.cc b/vendor/jsonbinpack/src/runtime/decoder_common.cc
deleted file mode 100644
index effd60c65..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_common.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include "unreachable.h"
-
-#include <cassert> // assert
-#include <variant> // std::get
-
-namespace sourcemeta::jsonbinpack {
-
-Decoder::Decoder(Stream &input) : InputStream{input} {}
-
-auto Decoder::read(const Encoding &encoding) -> sourcemeta::core::JSON {
-  switch (encoding.index()) {
-#define HANDLE_DECODING(index, name)                                           \
-  case (index):                                                                \
-    return this->name(std::get<sourcemeta::jsonbinpack::name>(encoding));
-    HANDLE_DECODING(0, BOUNDED_MULTIPLE_8BITS_ENUM_FIXED)
-    HANDLE_DECODING(1, FLOOR_MULTIPLE_ENUM_VARINT)
-    HANDLE_DECODING(2, ROOF_MULTIPLE_MIRROR_ENUM_VARINT)
-    HANDLE_DECODING(3, ARBITRARY_MULTIPLE_ZIGZAG_VARINT)
-    HANDLE_DECODING(4, DOUBLE_VARINT_TUPLE)
-    HANDLE_DECODING(5, BYTE_CHOICE_INDEX)
-    HANDLE_DECODING(6, LARGE_CHOICE_INDEX)
-    HANDLE_DECODING(7, TOP_LEVEL_BYTE_CHOICE_INDEX)
-    HANDLE_DECODING(8, CONST_NONE)
-    HANDLE_DECODING(9, ANY_PACKED_TYPE_TAG_BYTE_PREFIX)
-    HANDLE_DECODING(10, UTF8_STRING_NO_LENGTH)
-    HANDLE_DECODING(11, FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_DECODING(12, ROOF_VARINT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_DECODING(13, BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_DECODING(14, RFC3339_DATE_INTEGER_TRIPLET)
-    HANDLE_DECODING(15, PREFIX_VARINT_LENGTH_STRING_SHARED)
-    HANDLE_DECODING(16, FIXED_TYPED_ARRAY)
-    HANDLE_DECODING(17, BOUNDED_8BITS_TYPED_ARRAY)
-    HANDLE_DECODING(18, FLOOR_TYPED_ARRAY)
-    HANDLE_DECODING(19, ROOF_TYPED_ARRAY)
-    HANDLE_DECODING(20, FIXED_TYPED_ARBITRARY_OBJECT)
-    HANDLE_DECODING(21, VARINT_TYPED_ARBITRARY_OBJECT)
-    HANDLE_DECODING(22, NUMBER_VARINT_TUPLE)
-#undef HANDLE_DECODING
-    default:
-      // We should never get here. If so, it is definitely a bug
-      unreachable();
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_integer.cc b/vendor/jsonbinpack/src/runtime/decoder_integer.cc
deleted file mode 100644
index 427f1b46b..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_integer.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint32_t, std::int64_t, std::uint64_t
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::BOUNDED_MULTIPLE_8BITS_ENUM_FIXED(
-    const struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED &options)
-    -> sourcemeta::core::JSON {
-  assert(options.multiplier > 0);
-  const std::uint8_t byte{this->get_byte()};
-  const std::int64_t closest_minimum{
-      sourcemeta::core::divide_ceil(options.minimum, options.multiplier)};
-  if (closest_minimum >= 0) {
-    const std::uint64_t closest_minimum_multiple{
-        static_cast<std::uint32_t>(closest_minimum) * options.multiplier};
-    // We trust the encoder that the data we are seeing
-    // corresponds to a valid 64-bit signed integer.
-    return sourcemeta::core::JSON{static_cast<std::int64_t>(
-        (byte * options.multiplier) + closest_minimum_multiple)};
-  }
-
-  const std::uint64_t closest_minimum_multiple{
-      sourcemeta::core::abs(closest_minimum) * options.multiplier};
-  // We trust the encoder that the data we are seeing
-  // corresponds to a valid 64-bit signed integer.
-  return sourcemeta::core::JSON{static_cast<std::int64_t>(
-      (byte * options.multiplier) - closest_minimum_multiple)};
-}
-
-auto Decoder::FLOOR_MULTIPLE_ENUM_VARINT(
-    const struct FLOOR_MULTIPLE_ENUM_VARINT &options)
-    -> sourcemeta::core::JSON {
-  assert(options.multiplier > 0);
-  const std::int64_t closest_minimum{
-      sourcemeta::core::divide_ceil(options.minimum, options.multiplier)};
-  if (closest_minimum >= 0) {
-    const std::uint64_t closest_minimum_multiple{
-        static_cast<std::uint32_t>(closest_minimum) * options.multiplier};
-    // We trust the encoder that the data we are seeing
-    // corresponds to a valid 64-bit signed integer.
-    return sourcemeta::core::JSON{static_cast<std::int64_t>(
-        (this->get_varint() * options.multiplier) + closest_minimum_multiple)};
-  }
-
-  const std::uint64_t closest_minimum_multiple{
-      sourcemeta::core::abs(closest_minimum) * options.multiplier};
-  // We trust the encoder that the data we are seeing
-  // corresponds to a valid 64-bit signed integer.
-  return sourcemeta::core::JSON{static_cast<std::int64_t>(
-      (this->get_varint() * options.multiplier) - closest_minimum_multiple)};
-}
-
-auto Decoder::ROOF_MULTIPLE_MIRROR_ENUM_VARINT(
-    const struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT &options)
-    -> sourcemeta::core::JSON {
-  assert(options.multiplier > 0);
-  const std::int64_t closest_maximum{
-      sourcemeta::core::divide_floor(options.maximum, options.multiplier)};
-  if (closest_maximum >= 0) {
-    const std::uint64_t closest_maximum_multiple{
-        static_cast<std::uint32_t>(closest_maximum) * options.multiplier};
-    // We trust the encoder that the data we are seeing
-    // corresponds to a valid 64-bit signed integer.
-    return sourcemeta::core::JSON{static_cast<std::int64_t>(
-        -(static_cast<std::int64_t>(this->get_varint() * options.multiplier)) +
-        static_cast<std::int64_t>(closest_maximum_multiple))};
-  }
-
-  const std::uint64_t closest_maximum_multiple{
-      sourcemeta::core::abs(closest_maximum) * options.multiplier};
-  // We trust the encoder that the data we are seeing
-  // corresponds to a valid 64-bit signed integer.
-  return sourcemeta::core::JSON{static_cast<std::int64_t>(
-      -(static_cast<std::int64_t>(this->get_varint() * options.multiplier)) -
-      static_cast<std::int64_t>(closest_maximum_multiple))};
-}
-
-auto Decoder::ARBITRARY_MULTIPLE_ZIGZAG_VARINT(
-    const struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT &options)
-    -> sourcemeta::core::JSON {
-  assert(options.multiplier > 0);
-  // We trust the encoder that the data we are seeing
-  // corresponds to a valid 64-bit signed integer.
-  return sourcemeta::core::JSON{
-      static_cast<std::int64_t>(this->get_varint_zigzag() *
-                                static_cast<std::int64_t>(options.multiplier))};
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_number.cc b/vendor/jsonbinpack/src/runtime/decoder_number.cc
deleted file mode 100644
index a9b909995..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_number.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cmath>   // std::isfinite
-#include <cstdint> // std::int64_t, std::uint64_t
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC optimize("no-reciprocal-math")
-#endif
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::DOUBLE_VARINT_TUPLE(
-    [[maybe_unused]] const struct DOUBLE_VARINT_TUPLE &options)
-    -> sourcemeta::core::JSON {
-#ifdef __clang__
-#pragma clang fp reciprocal(off)
-#endif
-  const std::int64_t digits{this->get_varint_zigzag()};
-  const std::uint64_t point{this->get_varint()};
-  double divisor{1.0};
-  for (std::uint64_t i = 0; i < point; ++i) {
-    divisor *= 10.0;
-  }
-  return sourcemeta::core::JSON{static_cast<double>(digits) / divisor};
-}
-
-auto Decoder::NUMBER_VARINT_TUPLE(
-    [[maybe_unused]] const struct NUMBER_VARINT_TUPLE &options)
-    -> sourcemeta::core::JSON {
-#ifdef __clang__
-#pragma clang fp reciprocal(off)
-#endif
-  const std::int64_t coefficient{this->get_varint_zigzag()};
-  const std::uint64_t tag{this->get_varint()};
-  const std::int64_t exponent{
-      sourcemeta::core::zigzag_decode<std::uint64_t>(tag >> 1)};
-
-  if ((tag & 1) != 0) {
-    return sourcemeta::core::JSON{
-        sourcemeta::core::Decimal{coefficient}.scale_by(
-            sourcemeta::core::Decimal{exponent})};
-  }
-
-  // A scale that has grown past the range of the type can only keep growing,
-  // so the loop stops there rather than counting out an exponent that a
-  // corrupt stream may have made arbitrarily large
-  const std::uint64_t shifts{exponent < 0
-                                 ? static_cast<std::uint64_t>(-exponent)
-                                 : static_cast<std::uint64_t>(exponent)};
-  double scale{1.0};
-  for (std::uint64_t index = 0; index < shifts && std::isfinite(scale);
-       ++index) {
-    scale *= 10.0;
-  }
-
-  return sourcemeta::core::JSON{exponent < 0
-                                    ? static_cast<double>(coefficient) / scale
-                                    : static_cast<double>(coefficient) * scale};
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_object.cc b/vendor/jsonbinpack/src/runtime/decoder_object.cc
deleted file mode 100644
index ebb056ec4..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_object.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint64_t
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::FIXED_TYPED_ARBITRARY_OBJECT(
-    const struct FIXED_TYPED_ARBITRARY_OBJECT &options)
-    -> sourcemeta::core::JSON {
-  sourcemeta::core::JSON document = sourcemeta::core::JSON::make_object();
-  for (std::size_t index = 0; index < options.size; index++) {
-    const sourcemeta::core::JSON key = this->read(*(options.key_encoding));
-    assert(key.is_string());
-    document.assign(key.to_string(), this->read(*(options.encoding)));
-  }
-
-  assert(document.size() == options.size);
-  return document;
-};
-
-auto Decoder::VARINT_TYPED_ARBITRARY_OBJECT(
-    const struct VARINT_TYPED_ARBITRARY_OBJECT &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t size{this->get_varint()};
-  sourcemeta::core::JSON document = sourcemeta::core::JSON::make_object();
-  for (std::size_t index = 0; index < size; index++) {
-    const sourcemeta::core::JSON key = this->read(*(options.key_encoding));
-    assert(key.is_string());
-    document.assign(key.to_string(), this->read(*(options.encoding)));
-  }
-
-  assert(document.size() == size);
-  return document;
-};
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/decoder_string.cc b/vendor/jsonbinpack/src/runtime/decoder_string.cc
deleted file mode 100644
index bcde88236..000000000
--- a/vendor/jsonbinpack/src/runtime/decoder_string.cc
+++ /dev/null
@@ -1,119 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint16_t, std::uint64_t
-#include <iomanip> // std::setw, std::setfill
-#include <sstream> // std::basic_ostringstream
-
-namespace sourcemeta::jsonbinpack {
-
-auto Decoder::UTF8_STRING_NO_LENGTH(const struct UTF8_STRING_NO_LENGTH &options)
-    -> sourcemeta::core::JSON {
-  return sourcemeta::core::JSON{this->get_string_utf8(options.size)};
-}
-
-auto Decoder::FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t prefix{this->get_varint()};
-  const bool is_shared{prefix == 0};
-  const std::uint64_t length{(is_shared ? this->get_varint() : prefix) +
-                             options.minimum - 1};
-  assert(length >= options.minimum);
-
-  if (is_shared) {
-    const std::uint64_t position{this->position()};
-    const std::uint64_t current{this->rewind(this->get_varint(), position)};
-    const sourcemeta::core::JSON value{this->get_string_utf8(length)};
-    this->seek(current);
-    return value;
-  }
-
-  return UTF8_STRING_NO_LENGTH({length});
-}
-
-auto Decoder::ROOF_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t prefix{this->get_varint()};
-  const bool is_shared{prefix == 0};
-  const std::uint64_t length{options.maximum -
-                             (is_shared ? this->get_varint() : prefix) + 1};
-  assert(length <= options.maximum);
-
-  if (is_shared) {
-    const std::uint64_t position{this->position()};
-    const std::uint64_t current{this->rewind(this->get_varint(), position)};
-    const sourcemeta::core::JSON value{UTF8_STRING_NO_LENGTH({length})};
-    this->seek(current);
-    return value;
-  }
-
-  return UTF8_STRING_NO_LENGTH({length});
-}
-
-auto Decoder::BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED(
-    const struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED &options)
-    -> sourcemeta::core::JSON {
-  assert(options.minimum <= options.maximum);
-  assert(sourcemeta::core::is_byte(options.maximum - options.minimum));
-  const std::uint8_t prefix{this->get_byte()};
-  const bool is_shared{prefix == 0};
-  const std::uint64_t length{(is_shared ? this->get_byte() : prefix) +
-                             options.minimum - 1};
-  assert(sourcemeta::core::is_within(length, options.minimum, options.maximum));
-
-  if (is_shared) {
-    const std::uint64_t position{this->position()};
-    const std::uint64_t current{this->rewind(this->get_varint(), position)};
-    const sourcemeta::core::JSON value{UTF8_STRING_NO_LENGTH({length})};
-    this->seek(current);
-    return value;
-  }
-
-  return UTF8_STRING_NO_LENGTH({length});
-}
-
-auto Decoder::RFC3339_DATE_INTEGER_TRIPLET(
-    [[maybe_unused]] const struct RFC3339_DATE_INTEGER_TRIPLET &options)
-    -> sourcemeta::core::JSON {
-  const std::uint16_t year{this->get_word()};
-  const std::uint8_t month{this->get_byte()};
-  const std::uint8_t day{this->get_byte()};
-
-  assert(year <= 9999);
-  assert(month >= 1 && month <= 12);
-  assert(day >= 1 && day <= 31);
-
-  std::basic_ostringstream<sourcemeta::core::JSON::Char,
-                           sourcemeta::core::JSON::CharTraits>
-      output;
-  output << std::setfill('0');
-  output << std::setw(4) << year;
-  output << "-";
-  // Cast the bytes to a larger integer, otherwise
-  // they will be interpreted as characters.
-  output << std::setw(2) << static_cast<std::uint16_t>(month);
-  output << "-";
-  output << std::setw(2) << static_cast<std::uint16_t>(day);
-
-  return sourcemeta::core::JSON{output.str()};
-}
-
-auto Decoder::PREFIX_VARINT_LENGTH_STRING_SHARED(
-    const struct PREFIX_VARINT_LENGTH_STRING_SHARED &options)
-    -> sourcemeta::core::JSON {
-  const std::uint64_t prefix{this->get_varint()};
-  if (prefix == 0) {
-    const std::uint64_t position{this->position()};
-    const std::uint64_t current{this->rewind(this->get_varint(), position)};
-    const sourcemeta::core::JSON value{
-        PREFIX_VARINT_LENGTH_STRING_SHARED(options)};
-    this->seek(current);
-    return value;
-  }
-
-  return sourcemeta::core::JSON{this->get_string_utf8(prefix - 1)};
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_any.cc b/vendor/jsonbinpack/src/runtime/encoder_any.cc
deleted file mode 100644
index 17242e9b7..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_any.cc
+++ /dev/null
@@ -1,209 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include "unreachable.h"
-
-#include <algorithm> // std::find_if
-#include <cassert>   // assert
-#include <cstdint>   // std::uint8_t, std::int64_t, std::uint64_t
-#include <iterator>  // std::cbegin, std::cend, std::distance
-#include <memory>    // std::make_shared
-#include <ranges>    // std::ranges
-#include <utility>   // std::move
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::BYTE_CHOICE_INDEX(const sourcemeta::core::JSON &document,
-                                const struct BYTE_CHOICE_INDEX &options)
-    -> void {
-  assert(!options.choices.empty());
-  assert(sourcemeta::core::is_byte(options.choices.size()));
-  const auto iterator{std::ranges::find(options.choices, document)};
-  assert(iterator != std::cend(options.choices));
-  const auto cursor{std::distance(std::cbegin(options.choices), iterator)};
-  assert(sourcemeta::core::is_within(
-      cursor, 0, static_cast<std::int64_t>(options.choices.size())));
-  this->put_byte(static_cast<std::uint8_t>(cursor));
-}
-
-auto Encoder::LARGE_CHOICE_INDEX(const sourcemeta::core::JSON &document,
-                                 const struct LARGE_CHOICE_INDEX &options)
-    -> void {
-  assert(!options.choices.empty());
-  const auto iterator{std::ranges::find_if(
-      options.choices,
-      [&document](const auto &choice) -> bool { return choice == document; })};
-  assert(iterator != std::cend(options.choices));
-  const auto cursor{std::distance(std::cbegin(options.choices), iterator)};
-  assert(sourcemeta::core::is_within(cursor, static_cast<std::uint64_t>(0),
-                                     options.choices.size() - 1));
-  this->put_varint(static_cast<std::uint64_t>(cursor));
-}
-
-auto Encoder::TOP_LEVEL_BYTE_CHOICE_INDEX(
-    const sourcemeta::core::JSON &document,
-    const struct TOP_LEVEL_BYTE_CHOICE_INDEX &options) -> void {
-  assert(!options.choices.empty());
-  assert(sourcemeta::core::is_byte(options.choices.size()));
-  const auto iterator{std::ranges::find_if(
-      options.choices,
-      [&document](auto const &choice) -> bool { return choice == document; })};
-  assert(iterator != std::cend(options.choices));
-  const auto cursor{std::distance(std::cbegin(options.choices), iterator)};
-  assert(sourcemeta::core::is_within(
-      cursor, 0, static_cast<std::int64_t>(options.choices.size()) - 1));
-  // This encoding encodes the first option of the enum as "no data"
-  if (cursor > 0) {
-    this->put_byte(static_cast<std::uint8_t>(cursor - 1));
-  }
-}
-
-auto Encoder::CONST_NONE(
-    [[maybe_unused]] const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct CONST_NONE &options) -> void {
-  assert(document == options.value);
-}
-
-auto Encoder::ANY_PACKED_TYPE_TAG_BYTE_PREFIX(
-    const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX &options)
-    -> void {
-  using namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX;
-  if (document.is_null()) {
-    this->put_byte(TYPE_OTHER | (SUBTYPE_NULL << TYPE_SIZE));
-  } else if (document.is_boolean()) {
-    const std::uint8_t subtype{document.to_boolean() ? SUBTYPE_TRUE
-                                                     : SUBTYPE_FALSE};
-    this->put_byte(TYPE_OTHER |
-                   static_cast<std::uint8_t>(subtype << TYPE_SIZE));
-  } else if (document.is_real() && document.is_integral()) {
-    const auto value{document.as_integer()};
-    if (value >= 0 && sourcemeta::core::is_byte(value)) {
-      this->put_byte(TYPE_OTHER | SUBTYPE_POSITIVE_REAL_INTEGER_BYTE
-                                      << TYPE_SIZE);
-      this->put_byte(static_cast<std::uint8_t>(value));
-    } else {
-      this->put_byte(TYPE_OTHER | SUBTYPE_NUMBER << TYPE_SIZE);
-      this->DOUBLE_VARINT_TUPLE(document, {});
-    }
-  } else if (document.is_real()) {
-    this->put_byte(TYPE_OTHER | SUBTYPE_NUMBER << TYPE_SIZE);
-    this->DOUBLE_VARINT_TUPLE(document, {});
-  } else if (document.is_integer()) {
-    const std::int64_t value{document.to_integer()};
-    const bool is_positive{value >= 0};
-    const std::uint64_t absolute{is_positive
-                                     ? static_cast<std::uint64_t>(value)
-                                     : sourcemeta::core::abs(value) - 1};
-    if (sourcemeta::core::is_byte(absolute)) {
-      const std::uint8_t type{is_positive ? TYPE_POSITIVE_INTEGER_BYTE
-                                          : TYPE_NEGATIVE_INTEGER_BYTE};
-      const std::uint8_t absolute_byte{static_cast<std::uint8_t>(absolute)};
-      if (absolute < sourcemeta::core::uint_max<5>) {
-        this->put_byte(
-            type | static_cast<std::uint8_t>((absolute_byte + 1) << TYPE_SIZE));
-      } else {
-        this->put_byte(type);
-        this->put_byte(absolute_byte);
-      }
-    } else {
-      const std::uint8_t subtype{is_positive ? SUBTYPE_POSITIVE_INTEGER
-                                             : SUBTYPE_NEGATIVE_INTEGER};
-      this->put_byte(TYPE_OTHER |
-                     static_cast<std::uint8_t>(subtype << TYPE_SIZE));
-      this->put_varint(absolute);
-    }
-  } else if (document.is_decimal()) {
-    this->put_byte(TYPE_OTHER |
-                   static_cast<std::uint8_t>(SUBTYPE_DECIMAL << TYPE_SIZE));
-    this->NUMBER_VARINT_TUPLE(document, {});
-  } else if (document.is_string()) {
-    const sourcemeta::core::JSON::String &value{document.to_string()};
-    const auto size{document.byte_size()};
-    const auto shared{this->cache_.find(value, Cache::Type::Standalone)};
-    if (size < sourcemeta::core::uint_max<5>) {
-      const std::uint8_t type{shared.has_value() ? TYPE_SHARED_STRING
-                                                 : TYPE_STRING};
-      this->put_byte(
-          static_cast<std::uint8_t>(type | ((size + 1) << TYPE_SIZE)));
-      if (shared.has_value()) {
-        this->put_varint(this->position() - shared.value());
-      } else {
-        this->cache_.record(value, this->position(), Cache::Type::Standalone);
-        this->put_string_utf8(value, size);
-      }
-    } else if (size >= sourcemeta::core::uint_max<5> &&
-               size <
-                   static_cast<std::uint64_t>(sourcemeta::core::uint_max<5>) *
-                       2 &&
-               !shared.has_value()) {
-      this->put_byte(static_cast<std::uint8_t>(
-          TYPE_LONG_STRING |
-          ((size - sourcemeta::core::uint_max<5>) << TYPE_SIZE)));
-      this->put_string_utf8(value, size);
-    } else if (size >= 2 << (SUBTYPE_LONG_STRING_BASE_EXPONENT_7 - 1) &&
-               !shared.has_value()) {
-      const std::uint8_t exponent{sourcemeta::core::closest_smallest_exponent(
-          size, 2, SUBTYPE_LONG_STRING_BASE_EXPONENT_7,
-          SUBTYPE_LONG_STRING_BASE_EXPONENT_10)};
-      this->put_byte(
-          static_cast<std::uint8_t>(TYPE_OTHER | (exponent << TYPE_SIZE)));
-      this->put_varint(size - static_cast<std::uint64_t>(2 << (exponent - 1)));
-      this->put_string_utf8(value, size);
-    } else {
-      // Exploit the fact that a shared string always starts
-      // with an impossible length marker (0) to avoid having
-      // to encode an additional tag
-      if (!shared.has_value()) {
-        this->put_byte(TYPE_STRING);
-      }
-
-      // If we got this far, the string is at least a certain length
-      FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED(
-          document,
-          {static_cast<std::uint64_t>(sourcemeta::core::uint_max<5> * 2)});
-      return;
-    }
-  } else if (document.is_array()) {
-    const auto size{document.size()};
-    if (size >= sourcemeta::core::uint_max<5>) {
-      this->put_byte(TYPE_ARRAY);
-      this->put_varint(size - sourcemeta::core::uint_max<5>);
-    } else {
-      this->put_byte(
-          static_cast<std::uint8_t>(TYPE_ARRAY | ((size + 1) << TYPE_SIZE)));
-    }
-
-    Encoding encoding{
-        sourcemeta::jsonbinpack::ANY_PACKED_TYPE_TAG_BYTE_PREFIX{}};
-    this->FIXED_TYPED_ARRAY(
-        document, {.size = size,
-                   .encoding = std::make_shared<Encoding>(std::move(encoding)),
-                   .prefix_encodings = {}});
-  } else if (document.is_object()) {
-    const auto size{document.size()};
-    if (size >= sourcemeta::core::uint_max<5>) {
-      this->put_byte(TYPE_OBJECT);
-      this->put_varint(size - sourcemeta::core::uint_max<5>);
-    } else {
-      this->put_byte(
-          static_cast<std::uint8_t>(TYPE_OBJECT | ((size + 1) << TYPE_SIZE)));
-    }
-
-    Encoding key_encoding{
-        sourcemeta::jsonbinpack::PREFIX_VARINT_LENGTH_STRING_SHARED{}};
-    Encoding value_encoding{
-        sourcemeta::jsonbinpack::ANY_PACKED_TYPE_TAG_BYTE_PREFIX{}};
-    this->FIXED_TYPED_ARBITRARY_OBJECT(
-        document,
-        {.size = size,
-         .key_encoding = std::make_shared<Encoding>(std::move(key_encoding)),
-         .encoding = std::make_shared<Encoding>(std::move(value_encoding))});
-  } else {
-    // We should never get here
-    unreachable();
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_array.cc b/vendor/jsonbinpack/src/runtime/encoder_array.cc
deleted file mode 100644
index e9e3f0258..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_array.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t
-#include <utility> // std::move
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::FIXED_TYPED_ARRAY(const sourcemeta::core::JSON &document,
-                                const struct FIXED_TYPED_ARRAY &options)
-    -> void {
-  assert(document.is_array());
-  assert(document.size() == options.size);
-  const auto prefix_encodings{options.prefix_encodings.size()};
-  assert(prefix_encodings <= document.size());
-  for (std::size_t index = 0; index < options.size; index++) {
-    const Encoding &encoding{prefix_encodings > index
-                                 ? options.prefix_encodings[index]
-                                 : *(options.encoding)};
-    this->write(document.at(index), encoding);
-  }
-}
-
-auto Encoder::BOUNDED_8BITS_TYPED_ARRAY(
-    const sourcemeta::core::JSON &document,
-    const struct BOUNDED_8BITS_TYPED_ARRAY &options) -> void {
-  assert(options.maximum >= options.minimum);
-  const auto size{document.size()};
-  assert(sourcemeta::core::is_within(size, options.minimum, options.maximum));
-  assert(sourcemeta::core::is_byte(options.maximum - options.minimum));
-  this->put_byte(static_cast<std::uint8_t>(size - options.minimum));
-  this->FIXED_TYPED_ARRAY(document,
-                          {.size = size,
-                           .encoding = options.encoding,
-                           .prefix_encodings = options.prefix_encodings});
-}
-
-auto Encoder::FLOOR_TYPED_ARRAY(const sourcemeta::core::JSON &document,
-                                const struct FLOOR_TYPED_ARRAY &options)
-    -> void {
-  const auto size{document.size()};
-  assert(size >= options.minimum);
-  this->put_varint(size - options.minimum);
-  this->FIXED_TYPED_ARRAY(document,
-                          {.size = size,
-                           .encoding = options.encoding,
-                           .prefix_encodings = options.prefix_encodings});
-}
-
-auto Encoder::ROOF_TYPED_ARRAY(const sourcemeta::core::JSON &document,
-                               const struct ROOF_TYPED_ARRAY &options) -> void {
-  const auto size{document.size()};
-  assert(size <= options.maximum);
-  this->put_varint(options.maximum - size);
-  this->FIXED_TYPED_ARRAY(document,
-                          {.size = size,
-                           .encoding = options.encoding,
-                           .prefix_encodings = options.prefix_encodings});
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_common.cc b/vendor/jsonbinpack/src/runtime/encoder_common.cc
deleted file mode 100644
index 1b7d3d60b..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_common.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include "unreachable.h"
-
-#include <cassert> // assert
-#include <variant> // std::get
-
-namespace sourcemeta::jsonbinpack {
-
-Encoder::Encoder(Stream &output) : OutputStream{output} {}
-
-auto Encoder::write(const sourcemeta::core::JSON &document,
-                    const Encoding &encoding) -> void {
-  switch (encoding.index()) {
-#define HANDLE_ENCODING(index, name)                                           \
-  case (index):                                                                \
-    return this->name(document,                                                \
-                      std::get<sourcemeta::jsonbinpack::name>(encoding));
-    HANDLE_ENCODING(0, BOUNDED_MULTIPLE_8BITS_ENUM_FIXED)
-    HANDLE_ENCODING(1, FLOOR_MULTIPLE_ENUM_VARINT)
-    HANDLE_ENCODING(2, ROOF_MULTIPLE_MIRROR_ENUM_VARINT)
-    HANDLE_ENCODING(3, ARBITRARY_MULTIPLE_ZIGZAG_VARINT)
-    HANDLE_ENCODING(4, DOUBLE_VARINT_TUPLE)
-    HANDLE_ENCODING(5, BYTE_CHOICE_INDEX)
-    HANDLE_ENCODING(6, LARGE_CHOICE_INDEX)
-    HANDLE_ENCODING(7, TOP_LEVEL_BYTE_CHOICE_INDEX)
-    HANDLE_ENCODING(8, CONST_NONE)
-    HANDLE_ENCODING(9, ANY_PACKED_TYPE_TAG_BYTE_PREFIX)
-    HANDLE_ENCODING(10, UTF8_STRING_NO_LENGTH)
-    HANDLE_ENCODING(11, FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_ENCODING(12, ROOF_VARINT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_ENCODING(13, BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED)
-    HANDLE_ENCODING(14, RFC3339_DATE_INTEGER_TRIPLET)
-    HANDLE_ENCODING(15, PREFIX_VARINT_LENGTH_STRING_SHARED)
-    HANDLE_ENCODING(16, FIXED_TYPED_ARRAY)
-    HANDLE_ENCODING(17, BOUNDED_8BITS_TYPED_ARRAY)
-    HANDLE_ENCODING(18, FLOOR_TYPED_ARRAY)
-    HANDLE_ENCODING(19, ROOF_TYPED_ARRAY)
-    HANDLE_ENCODING(20, FIXED_TYPED_ARBITRARY_OBJECT)
-    HANDLE_ENCODING(21, VARINT_TYPED_ARBITRARY_OBJECT)
-    HANDLE_ENCODING(22, NUMBER_VARINT_TUPLE)
-#undef HANDLE_ENCODING
-    default:
-      // We should never get here. If so, it is definitely a bug
-      unreachable();
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_integer.cc b/vendor/jsonbinpack/src/runtime/encoder_integer.cc
deleted file mode 100644
index 2a2ba79ae..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_integer.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::int64_t, std::uint64_t
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::BOUNDED_MULTIPLE_8BITS_ENUM_FIXED(
-    const sourcemeta::core::JSON &document,
-    const struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED &options) -> void {
-  assert(document.is_integer());
-  const std::int64_t value{document.to_integer()};
-  assert(sourcemeta::core::is_within(value, options.minimum, options.maximum));
-  assert(options.multiplier > 0);
-  assert(sourcemeta::core::abs(value) % options.multiplier == 0);
-  const std::int64_t enum_minimum{
-      sourcemeta::core::divide_ceil(options.minimum, options.multiplier)};
-#ifndef NDEBUG
-  const std::int64_t enum_maximum{
-      sourcemeta::core::divide_floor(options.maximum, options.multiplier)};
-#endif
-  assert(sourcemeta::core::is_byte(enum_maximum - enum_minimum));
-  this->put_byte(static_cast<std::uint8_t>(
-      (value / static_cast<std::int64_t>(options.multiplier)) - enum_minimum));
-}
-
-auto Encoder::FLOOR_MULTIPLE_ENUM_VARINT(
-    const sourcemeta::core::JSON &document,
-    const struct FLOOR_MULTIPLE_ENUM_VARINT &options) -> void {
-  assert(document.is_integer());
-  const std::int64_t value{document.to_integer()};
-  assert(options.minimum <= value);
-  assert(options.multiplier > 0);
-  assert(sourcemeta::core::abs(value) % options.multiplier == 0);
-  if (options.multiplier == 1) {
-    this->put_varint(static_cast<std::uint64_t>(value - options.minimum));
-    return;
-  }
-
-  this->put_varint(
-      (static_cast<std::uint64_t>(value) / options.multiplier) -
-      static_cast<std::uint64_t>(sourcemeta::core::divide_ceil(
-          options.minimum, static_cast<std::uint64_t>(options.multiplier))));
-}
-
-auto Encoder::ROOF_MULTIPLE_MIRROR_ENUM_VARINT(
-    const sourcemeta::core::JSON &document,
-    const struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT &options) -> void {
-  assert(document.is_integer());
-  const std::int64_t value{document.to_integer()};
-  assert(value <= options.maximum);
-  assert(options.multiplier > 0);
-  assert(sourcemeta::core::abs(value) % options.multiplier == 0);
-  if (options.multiplier == 1) {
-    this->put_varint(static_cast<std::uint64_t>(options.maximum - value));
-    return;
-  }
-
-  this->put_varint(static_cast<std::uint64_t>(sourcemeta::core::divide_floor(
-                       options.maximum, options.multiplier)) -
-                   (static_cast<std::uint64_t>(value) / options.multiplier));
-}
-
-auto Encoder::ARBITRARY_MULTIPLE_ZIGZAG_VARINT(
-    const sourcemeta::core::JSON &document,
-    const struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT &options) -> void {
-  assert(document.is_integer());
-  const std::int64_t value{document.to_integer()};
-  assert(options.multiplier > 0);
-  assert(sourcemeta::core::abs(value) % options.multiplier == 0);
-  this->put_varint_zigzag(value /
-                          static_cast<std::int64_t>(options.multiplier));
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_number.cc b/vendor/jsonbinpack/src/runtime/encoder_number.cc
deleted file mode 100644
index 7118af90c..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_number.cc
+++ /dev/null
@@ -1,115 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert>      // assert
-#include <charconv>     // std::from_chars
-#include <cstddef>      // std::size_t
-#include <cstdint>      // std::int64_t, std::uint64_t
-#include <limits>       // std::numeric_limits
-#include <string_view>  // std::string_view
-#include <system_error> // std::errc
-
-namespace {
-
-#ifndef NDEBUG
-// The widest coefficient that still fits in a signed 64-bit integer
-constexpr std::size_t MAXIMUM_COEFFICIENT_DIGITS{19};
-#endif
-
-// The coefficient and the base-10 exponent of an arbitrary precision decimal.
-// Core keeps both of them private and only spells them out through the
-// scientific form, as `[-]D[.DDDD]e(+|-)ADJUSTED`, whose exponent is adjusted
-// to count from the leading digit rather than from the last one
-auto decimal_coefficient(const sourcemeta::core::Decimal &value,
-                         std::int64_t &exponent) -> std::int64_t {
-  const auto scientific{value.reduce().to_scientific_string()};
-  const std::string_view view{scientific};
-  const auto marker{view.find('e')};
-  assert(marker != std::string_view::npos);
-
-  auto mantissa{view.substr(0, marker)};
-  const auto negative{mantissa.front() == '-'};
-  if (negative) {
-    mantissa.remove_prefix(1);
-  }
-
-  // Every digit past the leading one sits after a decimal mark that the
-  // adjusted exponent already accounts for
-  const auto point{mantissa.find('.')};
-  const auto leading{mantissa.substr(
-      0, point == std::string_view::npos ? mantissa.size() : point)};
-  const auto trailing{point == std::string_view::npos
-                          ? std::string_view{}
-                          : mantissa.substr(point + 1)};
-
-  const auto digits{leading.size() + trailing.size()};
-  assert(digits >= 1);
-  assert(digits <= MAXIMUM_COEFFICIENT_DIGITS);
-
-  std::uint64_t magnitude{0};
-  for (const auto digit : leading) {
-    magnitude = (magnitude * 10) + static_cast<std::uint64_t>(digit - '0');
-  }
-  for (const auto digit : trailing) {
-    magnitude = (magnitude * 10) + static_cast<std::uint64_t>(digit - '0');
-  }
-
-  assert(magnitude <=
-         static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()));
-
-  auto adjusted_exponent{view.substr(marker + 1)};
-  if (adjusted_exponent.front() == '+') {
-    adjusted_exponent.remove_prefix(1);
-  }
-
-  std::int64_t adjusted{0};
-  [[maybe_unused]] const auto conversion{std::from_chars(
-      adjusted_exponent.data(),
-      adjusted_exponent.data() + adjusted_exponent.size(), adjusted)};
-  assert(conversion.ec == std::errc{});
-
-  exponent = adjusted - static_cast<std::int64_t>(digits - 1);
-  const auto coefficient{static_cast<std::int64_t>(magnitude)};
-  return negative ? -coefficient : coefficient;
-}
-
-} // namespace
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::DOUBLE_VARINT_TUPLE(
-    const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct DOUBLE_VARINT_TUPLE &options) -> void {
-  assert(document.is_real());
-  const auto value{document.to_real()};
-  std::uint64_t point_position;
-  const std::int64_t integral{
-      sourcemeta::core::real_digits<std::int64_t>(value, point_position)};
-  this->put_varint_zigzag(integral);
-  this->put_varint(point_position);
-}
-
-auto Encoder::NUMBER_VARINT_TUPLE(
-    const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct NUMBER_VARINT_TUPLE &options) -> void {
-  assert(document.is_real() || document.is_decimal());
-  const auto decimal{document.is_decimal()};
-  std::int64_t coefficient{0};
-  std::int64_t exponent{0};
-
-  if (decimal) {
-    coefficient = decimal_coefficient(document.to_decimal(), exponent);
-  } else {
-    std::uint64_t point_position;
-    coefficient = sourcemeta::core::real_digits<std::int64_t>(
-        document.to_real(), point_position);
-    exponent = -static_cast<std::int64_t>(point_position);
-  }
-
-  this->put_varint_zigzag(coefficient);
-  this->put_varint((sourcemeta::core::zigzag_encode(exponent) << 1) |
-                   static_cast<std::uint64_t>(decimal));
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_object.cc b/vendor/jsonbinpack/src/runtime/encoder_object.cc
deleted file mode 100644
index c2f5465be..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_object.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <cassert> // assert
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::FIXED_TYPED_ARBITRARY_OBJECT(
-    const sourcemeta::core::JSON &document,
-    const struct FIXED_TYPED_ARBITRARY_OBJECT &options) -> void {
-  assert(document.is_object());
-  assert(document.size() == options.size);
-
-  for (const auto &entry : document.as_object()) {
-    this->write(sourcemeta::core::JSON{entry.first}, *(options.key_encoding));
-    this->write(entry.second, *(options.encoding));
-  }
-}
-
-auto Encoder::VARINT_TYPED_ARBITRARY_OBJECT(
-    const sourcemeta::core::JSON &document,
-    const struct VARINT_TYPED_ARBITRARY_OBJECT &options) -> void {
-  assert(document.is_object());
-  const auto size{document.size()};
-  this->put_varint(size);
-
-  for (const auto &entry : document.as_object()) {
-    this->write(sourcemeta::core::JSON{entry.first}, *(options.key_encoding));
-    this->write(entry.second, *(options.encoding));
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/encoder_string.cc b/vendor/jsonbinpack/src/runtime/encoder_string.cc
deleted file mode 100644
index dda419f9c..000000000
--- a/vendor/jsonbinpack/src/runtime/encoder_string.cc
+++ /dev/null
@@ -1,152 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint16_t
-#include <string>  // std::stoul
-
-namespace sourcemeta::jsonbinpack {
-
-auto Encoder::UTF8_STRING_NO_LENGTH(const sourcemeta::core::JSON &document,
-                                    const struct UTF8_STRING_NO_LENGTH &options)
-    -> void {
-  assert(document.is_string());
-  const sourcemeta::core::JSON::String &value{document.to_string()};
-  this->put_string_utf8(value, options.size);
-}
-
-auto Encoder::FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &document,
-    const struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED &options) -> void {
-  assert(document.is_string());
-  const sourcemeta::core::JSON::String &value{document.to_string()};
-  const auto size{value.size()};
-  assert(document.byte_size() == size);
-  const auto shared{this->cache_.find(value, Cache::Type::Standalone)};
-
-  // (1) Write 0x00 if shared, else do nothing
-  if (shared.has_value()) {
-    this->put_byte(0);
-  }
-
-  // (2) Write length of the string + 1 (so it will never be zero)
-  this->put_varint(size - options.minimum + 1);
-
-  // (3) Write relative offset if shared, else write plain string
-  if (shared.has_value()) {
-    this->put_varint(this->position() - shared.value());
-  } else {
-    this->cache_.record(value, this->position(), Cache::Type::Standalone);
-    this->put_string_utf8(value, size);
-  }
-}
-
-auto Encoder::ROOF_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &document,
-    const struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED &options) -> void {
-  assert(document.is_string());
-  const sourcemeta::core::JSON::String &value{document.to_string()};
-  const auto size{value.size()};
-  assert(document.byte_size() == size);
-  assert(size <= options.maximum);
-  const auto shared{this->cache_.find(value, Cache::Type::Standalone)};
-
-  // (1) Write 0x00 if shared, else do nothing
-  if (shared.has_value()) {
-    this->put_byte(0);
-  }
-
-  // (2) Write length of the string + 1 (so it will never be zero)
-  this->put_varint(options.maximum - size + 1);
-
-  // (3) Write relative offset if shared, else write plain string
-  if (shared.has_value()) {
-    this->put_varint(this->position() - shared.value());
-  } else {
-    this->cache_.record(value, this->position(), Cache::Type::Standalone);
-    this->put_string_utf8(value, size);
-  }
-}
-
-auto Encoder::BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &document,
-    const struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED &options) -> void {
-  assert(document.is_string());
-  const sourcemeta::core::JSON::String &value{document.to_string()};
-  const auto size{value.size()};
-  assert(document.byte_size() == size);
-  assert(options.minimum <= options.maximum);
-  assert(sourcemeta::core::is_byte(options.maximum - options.minimum + 1));
-  assert(sourcemeta::core::is_within(size, options.minimum, options.maximum));
-  const auto shared{this->cache_.find(value, Cache::Type::Standalone)};
-
-  // (1) Write 0x00 if shared, else do nothing
-  if (shared.has_value()) {
-    this->put_byte(0);
-  }
-
-  // (2) Write length of the string + 1 (so it will never be zero)
-  this->put_byte(static_cast<std::uint8_t>(size - options.minimum + 1));
-
-  // (3) Write relative offset if shared, else write plain string
-  if (shared.has_value()) {
-    this->put_varint(this->position() - shared.value());
-  } else {
-    this->cache_.record(value, this->position(), Cache::Type::Standalone);
-    this->put_string_utf8(value, size);
-  }
-}
-
-auto Encoder::RFC3339_DATE_INTEGER_TRIPLET(
-    const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct RFC3339_DATE_INTEGER_TRIPLET &options)
-    -> void {
-  assert(document.is_string());
-  const auto &value{document.to_string()};
-  assert(value.size() == 10);
-  assert(document.size() == value.size());
-
-  // As according to RFC3339: Internet Protocols MUST
-  // generate four digit years in dates.
-  const std::uint16_t year{
-      static_cast<std::uint16_t>(std::stoul(value.substr(0, 4)))};
-  const std::uint8_t month{
-      static_cast<std::uint8_t>(std::stoul(value.substr(5, 2)))};
-  const std::uint8_t day{
-      static_cast<std::uint8_t>(std::stoul(value.substr(8, 2)))};
-  assert(month >= 1 && month <= 12);
-  assert(day >= 1 && day <= 31);
-
-  this->put_word(year);
-  this->put_byte(month);
-  this->put_byte(day);
-}
-
-auto Encoder::PREFIX_VARINT_LENGTH_STRING_SHARED(
-    const sourcemeta::core::JSON &document,
-    [[maybe_unused]] const struct PREFIX_VARINT_LENGTH_STRING_SHARED &options)
-    -> void {
-  assert(document.is_string());
-  const sourcemeta::core::JSON::String &value{document.to_string()};
-
-  const auto shared{
-      this->cache_.find(value, Cache::Type::PrefixLengthVarintPlusOne)};
-  if (shared.has_value()) {
-    const auto new_offset{this->position()};
-    this->put_byte(0);
-    this->put_varint(this->position() - shared.value());
-    // Bump the context cache for locality purposes
-    this->cache_.record(value, new_offset,
-                        Cache::Type::PrefixLengthVarintPlusOne);
-  } else {
-    const auto size{value.size()};
-    assert(document.byte_size() == size);
-    this->cache_.record(value, this->position(),
-                        Cache::Type::PrefixLengthVarintPlusOne);
-    this->put_varint(size + 1);
-    // Also record a standalone variant of it
-    this->cache_.record(value, this->position(), Cache::Type::Standalone);
-    this->put_string_utf8(value, size);
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime.h
deleted file mode 100644
index f4663635b..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_H_
-
-/// @defgroup runtime Runtime
-/// @brief The encoder/decoder parts of JSON BinPack
-///
-/// This functionality is included as follows:
-///
-/// ```cpp
-/// #include <sourcemeta/jsonbinpack/runtime.h>
-/// ```
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/core/json.h>
-
-#include <sourcemeta/jsonbinpack/runtime_decoder.h>
-#include <sourcemeta/jsonbinpack/runtime_encoder.h>
-#include <sourcemeta/jsonbinpack/runtime_encoding.h>
-
-#include <exception> // std::exception
-#include <utility>   // std::move
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup runtime
-SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-auto load(const sourcemeta::core::JSON &input) -> Encoding;
-
-// Exporting symbols that depends on the standard C++ library is considered
-// safe.
-// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
-#if defined(_MSC_VER)
-#pragma warning(disable : 4251 4275)
-#endif
-
-/// @ingroup runtime
-/// This class represents an encoding error
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT EncodingError
-    : public std::exception {
-public:
-  EncodingError(sourcemeta::core::JSON::String message)
-      : message_{std::move(message)} {}
-
-  [[nodiscard]] auto what() const noexcept -> const char * override {
-    return this->message_.c_str();
-  }
-
-private:
-  sourcemeta::core::JSON::String message_;
-};
-
-#if defined(_MSC_VER)
-#pragma warning(default : 4251 4275)
-#endif
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_decoder.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_decoder.h
deleted file mode 100644
index 9327cb5b9..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_decoder.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_DECODER_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_DECODER_H_
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/jsonbinpack/runtime_encoding.h>
-#include <sourcemeta/jsonbinpack/runtime_input_stream.h>
-
-#include <sourcemeta/core/json.h>
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup runtime
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT Decoder : private InputStream {
-public:
-  Decoder(Stream &input);
-  auto read(const Encoding &encoding) -> sourcemeta::core::JSON;
-
-// The methods that implement individual encodings as considered private
-#ifndef DOXYGEN
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-#define DECLARE_ENCODING(name)                                                 \
-  auto name(const name &) -> sourcemeta::core::JSON;
-
-  // Integer
-  DECLARE_ENCODING(BOUNDED_MULTIPLE_8BITS_ENUM_FIXED)
-  DECLARE_ENCODING(FLOOR_MULTIPLE_ENUM_VARINT)
-  DECLARE_ENCODING(ROOF_MULTIPLE_MIRROR_ENUM_VARINT)
-  DECLARE_ENCODING(ARBITRARY_MULTIPLE_ZIGZAG_VARINT)
-
-  // Number
-  DECLARE_ENCODING(DOUBLE_VARINT_TUPLE)
-  DECLARE_ENCODING(NUMBER_VARINT_TUPLE)
-
-  // Any
-  DECLARE_ENCODING(BYTE_CHOICE_INDEX)
-  DECLARE_ENCODING(LARGE_CHOICE_INDEX)
-  DECLARE_ENCODING(TOP_LEVEL_BYTE_CHOICE_INDEX)
-  DECLARE_ENCODING(CONST_NONE)
-  DECLARE_ENCODING(ANY_PACKED_TYPE_TAG_BYTE_PREFIX)
-
-  // String
-  DECLARE_ENCODING(UTF8_STRING_NO_LENGTH)
-  DECLARE_ENCODING(FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(ROOF_VARINT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(RFC3339_DATE_INTEGER_TRIPLET)
-  DECLARE_ENCODING(PREFIX_VARINT_LENGTH_STRING_SHARED)
-  // TODO: Implement STRING_BROTLI encoding
-  // TODO: Implement STRING_DICTIONARY_COMPRESSOR encoding
-  // TODO: Implement STRING_UNBOUNDED_SCOPED_PREFIX_LENGTH encoding
-  // TODO: Implement URL_PROTOCOL_HOST_REST encoding
-
-  // Array
-  DECLARE_ENCODING(FIXED_TYPED_ARRAY)
-  DECLARE_ENCODING(BOUNDED_8BITS_TYPED_ARRAY)
-  DECLARE_ENCODING(FLOOR_TYPED_ARRAY)
-  DECLARE_ENCODING(ROOF_TYPED_ARRAY)
-
-  // Object
-  DECLARE_ENCODING(FIXED_TYPED_ARBITRARY_OBJECT)
-  DECLARE_ENCODING(VARINT_TYPED_ARBITRARY_OBJECT)
-
-#undef DECLARE_ENCODING
-// NOLINTEND(readability-identifier-naming)
-#endif
-};
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder.h
deleted file mode 100644
index 0ec4eaf37..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_ENCODER_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_ENCODER_H_
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/jsonbinpack/runtime_encoder_cache.h>
-#include <sourcemeta/jsonbinpack/runtime_encoding.h>
-#include <sourcemeta/jsonbinpack/runtime_output_stream.h>
-
-#include <sourcemeta/core/json.h>
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup runtime
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT Encoder : private OutputStream {
-public:
-  Encoder(Stream &output);
-  auto write(const sourcemeta::core::JSON &document, const Encoding &encoding)
-      -> void;
-
-// The methods that implement individual encodings as considered private
-#ifndef DOXYGEN
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-#define DECLARE_ENCODING(name)                                                 \
-  auto name(const sourcemeta::core::JSON &document, const name &) -> void;
-
-  // Integer
-  DECLARE_ENCODING(BOUNDED_MULTIPLE_8BITS_ENUM_FIXED)
-  DECLARE_ENCODING(FLOOR_MULTIPLE_ENUM_VARINT)
-  DECLARE_ENCODING(ROOF_MULTIPLE_MIRROR_ENUM_VARINT)
-  DECLARE_ENCODING(ARBITRARY_MULTIPLE_ZIGZAG_VARINT)
-
-  // Number
-  DECLARE_ENCODING(DOUBLE_VARINT_TUPLE)
-  DECLARE_ENCODING(NUMBER_VARINT_TUPLE)
-
-  // Any
-  DECLARE_ENCODING(BYTE_CHOICE_INDEX)
-  DECLARE_ENCODING(LARGE_CHOICE_INDEX)
-  DECLARE_ENCODING(TOP_LEVEL_BYTE_CHOICE_INDEX)
-  DECLARE_ENCODING(CONST_NONE)
-  DECLARE_ENCODING(ANY_PACKED_TYPE_TAG_BYTE_PREFIX)
-
-  // String
-  DECLARE_ENCODING(UTF8_STRING_NO_LENGTH)
-  DECLARE_ENCODING(FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(ROOF_VARINT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED)
-  DECLARE_ENCODING(RFC3339_DATE_INTEGER_TRIPLET)
-  DECLARE_ENCODING(PREFIX_VARINT_LENGTH_STRING_SHARED)
-  // TODO: Implement STRING_BROTLI encoding
-  // TODO: Implement STRING_DICTIONARY_COMPRESSOR encoding
-  // TODO: Implement STRING_UNBOUNDED_SCOPED_PREFIX_LENGTH encoding
-  // TODO: Implement URL_PROTOCOL_HOST_REST encoding
-
-  // Array
-  DECLARE_ENCODING(FIXED_TYPED_ARRAY)
-  DECLARE_ENCODING(BOUNDED_8BITS_TYPED_ARRAY)
-  DECLARE_ENCODING(FLOOR_TYPED_ARRAY)
-  DECLARE_ENCODING(ROOF_TYPED_ARRAY)
-
-  // Object
-  DECLARE_ENCODING(FIXED_TYPED_ARBITRARY_OBJECT)
-  DECLARE_ENCODING(VARINT_TYPED_ARBITRARY_OBJECT)
-
-#undef DECLARE_ENCODING
-// NOLINTEND(readability-identifier-naming)
-#endif
-
-private:
-  Cache cache_;
-};
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder_cache.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder_cache.h
deleted file mode 100644
index 9d3e40c1f..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoder_cache.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_ENCODER_CACHE_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_ENCODER_CACHE_H_
-#ifndef DOXYGEN
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/core/json.h>
-
-#include <functional> // std::reference_wrapper
-#include <map>        // std::map
-#include <optional>   // std::optional
-#include <utility>    // std::pair
-
-namespace sourcemeta::jsonbinpack {
-
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT Cache {
-public:
-  enum class Type : std::uint8_t { Standalone, PrefixLengthVarintPlusOne };
-  auto record(const sourcemeta::core::JSON::String &value,
-              const std::uint64_t offset, const Type type) -> void;
-  [[nodiscard]] auto find(const sourcemeta::core::JSON::String &value,
-                          const Type type) const
-      -> std::optional<std::uint64_t>;
-
-#ifndef DOXYGEN
-  // This method is considered private. We only expose it for testing purposes
-  auto remove_oldest() -> void;
-#endif
-
-private:
-// Exporting symbols that depends on the standard C++ library is considered
-// safe.
-// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
-#if defined(_MSC_VER)
-#pragma warning(disable : 4251 4275)
-#endif
-  std::uint64_t byte_size_{0};
-  using Entry = std::pair<sourcemeta::core::JSON::String, Type>;
-  std::map<Entry, std::uint64_t> data_;
-  std::map<std::uint64_t, std::reference_wrapper<const Entry>> order_;
-#if defined(_MSC_VER)
-#pragma warning(default : 4251 4275)
-#endif
-};
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoding.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoding.h
deleted file mode 100644
index 110277c53..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_encoding.h
+++ /dev/null
@@ -1,1121 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_ENCODING_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_ENCODING_H_
-
-#include <sourcemeta/core/json.h>
-#include <sourcemeta/core/numeric.h>
-
-#include <cstdint> // std::int64_t, std::uint64_t
-#include <memory>  // std::shared_ptr
-#include <variant> // std::variant
-#include <vector>  // std::vector
-
-namespace sourcemeta::jsonbinpack {
-
-// Forward declarations for the sole purpose of being bale to define circular
-// structures
-#ifndef DOXYGEN
-// The encoding names are the ones the JSON BinPack specification
-// defines, so they keep their casing rather than following the C++
-// naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED;
-struct FLOOR_MULTIPLE_ENUM_VARINT;
-struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT;
-struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT;
-struct DOUBLE_VARINT_TUPLE;
-struct NUMBER_VARINT_TUPLE;
-struct BYTE_CHOICE_INDEX;
-struct LARGE_CHOICE_INDEX;
-struct TOP_LEVEL_BYTE_CHOICE_INDEX;
-struct CONST_NONE;
-struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX;
-struct UTF8_STRING_NO_LENGTH;
-struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED;
-struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED;
-struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED;
-struct RFC3339_DATE_INTEGER_TRIPLET;
-struct PREFIX_VARINT_LENGTH_STRING_SHARED;
-struct FIXED_TYPED_ARRAY;
-struct BOUNDED_8BITS_TYPED_ARRAY;
-struct FLOOR_TYPED_ARRAY;
-struct ROOF_TYPED_ARRAY;
-struct FIXED_TYPED_ARBITRARY_OBJECT;
-struct VARINT_TYPED_ARBITRARY_OBJECT;
-// NOLINTEND(readability-identifier-naming)
-#endif
-
-/// @ingroup runtime
-/// Represents an encoding
-using Encoding = std::variant<
-    BOUNDED_MULTIPLE_8BITS_ENUM_FIXED, FLOOR_MULTIPLE_ENUM_VARINT,
-    ROOF_MULTIPLE_MIRROR_ENUM_VARINT, ARBITRARY_MULTIPLE_ZIGZAG_VARINT,
-    DOUBLE_VARINT_TUPLE, BYTE_CHOICE_INDEX, LARGE_CHOICE_INDEX,
-    TOP_LEVEL_BYTE_CHOICE_INDEX, CONST_NONE, ANY_PACKED_TYPE_TAG_BYTE_PREFIX,
-    UTF8_STRING_NO_LENGTH, FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED,
-    ROOF_VARINT_PREFIX_UTF8_STRING_SHARED,
-    BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED, RFC3339_DATE_INTEGER_TRIPLET,
-    PREFIX_VARINT_LENGTH_STRING_SHARED, FIXED_TYPED_ARRAY,
-    BOUNDED_8BITS_TYPED_ARRAY, FLOOR_TYPED_ARRAY, ROOF_TYPED_ARRAY,
-    FIXED_TYPED_ARBITRARY_OBJECT, VARINT_TYPED_ARBITRARY_OBJECT,
-    NUMBER_VARINT_TUPLE>;
-
-// The encoding names are the ones the JSON BinPack specification
-// defines, so they keep their casing rather than following the C++
-// naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-/// @ingroup runtime
-/// @defgroup encoding_integer Integer Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consists of the integer value divided by the
-/// `multiplier`, minus the ceil of `minimum` divided by the `multiplier`,
-/// encoded as an 8-bit fixed-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option       | Type   | Description                 |
-/// |--------------|--------|-----------------------------|
-/// | `minimum`    | `int`  | The inclusive minimum value |
-/// | `maximum`    | `int`  | The inclusive maximum value |
-/// | `multiplier` | `uint` | The multiplier value        |
-///
-/// ### Conditions
-///
-/// | Condition                    | Description                                                         |
-/// |------------------------------|---------------------------------------------------------------------|
-/// | `value >= minimum`           | The input value must be greater than or equal to the minimum        |
-/// | `value <= maximum`           | The input value must be less than or equal to the maximum           |
-/// | `value % multiplier == 0`    | The input value must be divisible by the multiplier                 |
-/// | `floor(maximum / multiplier) - ceil(minimum / multiplier) < 2 ** 8` | The divided range must be representable in 8 bits |
-///
-/// ### Examples
-///
-/// Given the input value 15, where the minimum is 1, the maximum is 19, and the
-/// multiplier is 5, the encoding results in the 8-bit unsigned integer 2:
-///
-/// ```
-/// +------+
-/// | 0x02 |
-/// +------+
-/// ```
-// clang-format on
-struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED {
-  /// The inclusive minimum value
-  std::int64_t minimum;
-  /// The inclusive maximum value
-  std::int64_t maximum;
-  /// The multiplier value
-  std::uint64_t multiplier;
-};
-
-// clang-format off
-/// @brief The encoding consists of the integer value divided by the
-/// `multiplier`, minus the ceil of `minimum` divided by the `multiplier`,
-/// encoded as a Base-128 64-bit Little Endian variable-length unsigned
-/// integer.
-///
-/// ### Options
-///
-/// | Option       | Type   | Description                 |
-/// |--------------|--------|-----------------------------|
-/// | `minimum`    | `int`  | The inclusive minimum value |
-/// | `multiplier` | `uint` | The multiplier value        |
-///
-/// ### Conditions
-///
-/// | Condition                 | Description                                                  |
-/// |---------------------------|--------------------------------------------------------------|
-/// | `value >= minimum`        | The input value must be greater than or equal to the minimum |
-/// | `value % multiplier == 0` | The input value must be divisible by the multiplier          |
-///
-/// ### Examples
-///
-/// Given the input value 1000, where the minimum is -2 and the multiplier is 4,
-/// the encoding results in the Base-128 64-bit Little Endian variable-length
-/// unsigned integer 250:
-///
-/// ```
-/// +------+------+
-/// | 0xfa | 0x01 |
-/// +------+------+
-/// ```
-// clang-format on
-struct FLOOR_MULTIPLE_ENUM_VARINT {
-  /// The inclusive minimum value
-  std::int64_t minimum;
-  /// The multiplier value
-  std::uint64_t multiplier;
-};
-
-// clang-format off
-/// @brief The encoding consists of the floor of `maximum` divided by the
-/// `multiplier`, minus the integer value divided by the `multiplier`, encoded
-/// as a Base-128 64-bit Little Endian variable-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option       | Type   | Description                 |
-/// |--------------|--------|-----------------------------|
-/// | `maximum`    | `int`  | The inclusive maximum value |
-/// | `multiplier` | `uint` | The multiplier value        |
-///
-/// ### Conditions
-///
-/// | Condition                 | Description                                               |
-/// |---------------------------|-----------------------------------------------------------|
-/// | `value <= maximum`        | The input value must be less than or equal to the maximum |
-/// | `value % multiplier == 0` | The input value must be divisible by the multiplier       |
-///
-/// ### Examples
-///
-/// Given the input value 5, where the maximum is 16 and the multiplier is 5, the
-/// encoding results in the Base-128 64-bit Little Endian variable-length unsigned
-/// integer 2:
-///
-/// ```
-/// +------+
-/// | 0x02 |
-/// +------+
-/// ```
-// clang-format on
-struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT {
-  /// The inclusive maximum value
-  std::int64_t maximum;
-  /// The multiplier value
-  std::uint64_t multiplier;
-};
-
-// clang-format off
-/// @brief The encoding consists of the the integer value divided by the
-/// `multiplier` encoded as a ZigZag-encoded Base-128 64-bit Little Endian
-/// variable-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option       | Type   | Description          |
-/// |--------------|--------|----------------------|
-/// | `multiplier` | `uint` | The multiplier value |
-///
-/// ### Conditions
-///
-/// | Condition                 | Description                                         |
-/// |---------------------------|-----------------------------------------------------|
-/// | `value % multiplier == 0` | The input value must be divisible by the multiplier |
-///
-/// ### Examples
-///
-/// Given the input value 10, where the multiplier is 5, the encoding results in
-/// the Base-128 64-bit Little Endian variable-length unsigned integer 4:
-///
-/// ```
-/// +------+
-/// | 0x04 |
-/// +------+
-/// ```
-// clang-format on
-struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT {
-  /// The multiplier value
-  std::uint64_t multiplier;
-};
-
-/// @}
-
-/// @ingroup runtime
-/// @defgroup encoding_number Number Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consists of a sequence of two integers: The signed
-/// integer that results from concatenating the integral part and the decimal
-/// part of the number, if any, as a ZigZag-encoded Base-128 64-bit Little
-/// Endian variable-length unsigned integer; and the position of the decimal
-/// mark from the last digit of the number encoded as a Base-128 64-bit Little
-/// Endian variable-length unsigned integer.
-///
-/// ### Options
-///
-/// None
-///
-/// ### Conditions
-///
-/// None
-///
-/// ### Examples
-///
-/// Given the input value 3.14, the encoding results in the variable-length integer
-/// 628 (the ZigZag encoding of 314) followed by the variable-length unsigned
-/// integer 2 (the number of decimal digits in the number).
-///
-/// ```
-/// +------+------+------+
-/// | 0xf4 | 0x04 | 0x02 |
-/// +------+------+------+
-/// ```
-///
-/// Real numbers that represent integers are encoded with a decimal mark of zero.
-/// Given the input value -5.0, the encoding results in the variable-length integer
-/// 9 (the ZigZag encoding of -5) followed by the variable-length unsigned integer
-/// 0.
-///
-/// ```
-/// +------+------+
-/// | 0x09 | 0x00 |
-/// +------+------+
-/// ```
-// clang-format on
-struct DOUBLE_VARINT_TUPLE {};
-
-// clang-format off
-/// @brief The encoding consists of a sequence of two integers. The first is
-/// the signed coefficient of the number as a ZigZag-encoded Base-128 64-bit
-/// Little Endian variable-length unsigned integer. The second is the base-10
-/// exponent that the coefficient is scaled by, ZigZag-encoded and shifted left
-/// by one bit, whose least significant bit is set when the number is an
-/// arbitrary-precision decimal rather than a double, as a Base-128 64-bit
-/// Little Endian variable-length unsigned integer.
-///
-/// Unlike DOUBLE_VARINT_TUPLE, this encoding covers both of the numeric
-/// representations that a JSON document may hold, and the schema-driven mode
-/// relies on that: a schema that permits a number cannot tell which of the two
-/// an instance will carry, so the distinction travels with the data. The
-/// exponent is signed so that magnitudes a decimal mark cannot reach, such as
-/// 1e300, remain within the encoding.
-///
-/// ### Options
-///
-/// None
-///
-/// ### Conditions
-///
-/// The coefficient must fit in a signed 64-bit integer, which holds every
-/// number of up to 19 significant digits
-///
-/// ### Examples
-///
-/// Given the decimal input value 2.1, the encoding results in the
-/// variable-length integer 42 (the ZigZag encoding of 21) followed by the
-/// variable-length unsigned integer 3 (the ZigZag encoding of the exponent -1,
-/// shifted left by one bit, with the decimal bit set).
-///
-/// ```
-/// +------+------+
-/// | 0x2a | 0x03 |
-/// +------+------+
-/// ```
-///
-/// Given the double input value 3.14, the encoding results in the
-/// variable-length integer 628 (the ZigZag encoding of 314) followed by the
-/// variable-length unsigned integer 6 (the ZigZag encoding of the exponent -2,
-/// shifted left by one bit, with the decimal bit clear).
-///
-/// ```
-/// +------+------+------+
-/// | 0xf4 | 0x04 | 0x06 |
-/// +------+------+------+
-/// ```
-// clang-format on
-struct NUMBER_VARINT_TUPLE {};
-
-/// @}
-
-/// @ingroup runtime
-/// @defgroup encoding_any Any Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consists of an index to the enumeration choices encoded
-/// as an 8-bit fixed-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option    | Type    | Description              |
-/// |-----------|---------|--------------------------|
-/// | `choices` | `any[]` | The set of choice values |
-///
-/// ### Conditions
-///
-/// | Condition                | Description                                            |
-/// |--------------------------|--------------------------------------------------------|
-/// | `len(choices) > 0`       | The choices array must not be empty                    |
-/// | `len(choices) <  2 ** 8` | The number of choices must be representable in 8 bits  |
-/// | `value in choices`       | The input value must be included in the set of choices |
-///
-/// ### Examples
-///
-/// Given an enumeration `[ "foo", "bar", "baz" ]` and an input value `"bar"`, the
-/// encoding results in the unsigned 8 bit integer 1:
-///
-/// ```
-/// +------+
-/// | 0x01 |
-/// +------+
-/// ```
-///
-/// Given an enumeration `[ "foo", "bar", "baz" ]` and an input value `"foo"`, the
-/// encoding results in the unsigned 8 bit integer 0:
-///
-/// ```
-/// +------+
-/// | 0x00 |
-/// +------+
-/// ```
-// clang-format on
-struct BYTE_CHOICE_INDEX {
-  /// The set of choice values
-  std::vector<sourcemeta::core::JSON> choices;
-};
-
-// clang-format off
-/// @brief The encoding consists of an index to the enumeration choices encoded
-/// as a Base-128 64-bit Little Endian variable-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option    | Type    | Description              |
-/// |-----------|---------|--------------------------|
-/// | `choices` | `any[]` | The set of choice values |
-///
-/// ### Conditions
-///
-/// | Condition                | Description                                            |
-/// |--------------------------|--------------------------------------------------------|
-/// | `len(choices) > 0`       | The choices array must not be empty                    |
-/// | `value in choices`       | The input value must be included in the set of choices |
-///
-/// ### Examples
-///
-/// Given an enumeration with 1000 members and an input value that equals the 300th
-/// enumeration value, the encoding results in the Base-128 64-bit Little Endian
-/// variable-length unsigned integer 300:
-///
-/// ```
-/// +------+------+
-/// | 0xac | 0x02 |
-/// +------+------+
-/// ```
-// clang-format on
-struct LARGE_CHOICE_INDEX {
-  /// The set of choice values
-  std::vector<sourcemeta::core::JSON> choices;
-};
-
-// clang-format off
-/// @brief If the input value corresponds to the index 0 to the enumeration
-/// choices, the encoding stores no data. Otherwise, the encoding consists of
-/// an index to the enumeration choices minus 1 encoded as an 8-bit
-/// fixed-length unsigned integer.
-///
-/// ### Options
-///
-/// | Option    | Type    | Description              |
-/// |-----------|---------|--------------------------|
-/// | `choices` | `any[]` | The set of choice values |
-///
-/// ### Conditions
-///
-/// | Condition                | Description                                            |
-/// |--------------------------|--------------------------------------------------------|
-/// | `len(choices) > 0`       | The choices array must not be empty                    |
-/// | `len(choices) <  2 ** 8` | The number of choices must be representable in 8 bits  |
-/// | `value in choices`       | The input value must be included in the set of choices |
-///
-/// ### Examples
-///
-/// Given an enumeration `[ "foo", "bar", "baz" ]` and an input value `"bar"`, the
-/// encoding results in the unsigned 8 bit integer 0:
-///
-/// ```
-/// +------+
-/// | 0x00 |
-/// +------+
-/// ```
-///
-/// Given an enumeration `[ "foo", "bar", "baz" ]` and an input value `"foo"`, the
-/// value is not encoded.
-// clang-format on
-struct TOP_LEVEL_BYTE_CHOICE_INDEX {
-  /// The set of choice values
-  std::vector<sourcemeta::core::JSON> choices;
-};
-
-// clang-format off
-/// @brief The constant input value is not encoded.
-///
-/// ### Options
-///
-/// | Option  | Type  | Description        |
-/// |---------|-------|--------------------|
-/// | `value` | `any` | The constant value |
-///
-/// ### Conditions
-///
-/// None
-///
-/// ### Examples
-///
-/// The input value that matches the `value` option is not encoded.
-// clang-format on
-struct CONST_NONE {
-  /// The constant value
-  sourcemeta::core::JSON value;
-};
-
-// TODO: Write brief description
-struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX {};
-#ifndef DOXYGEN
-namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX {
-constexpr auto TYPE_SIZE = 3;
-constexpr std::uint8_t TYPE_SHARED_STRING = 0b00000000;
-constexpr std::uint8_t TYPE_STRING = 0b00000001;
-constexpr std::uint8_t TYPE_LONG_STRING = 0b00000010;
-constexpr std::uint8_t TYPE_OBJECT = 0b00000011;
-constexpr std::uint8_t TYPE_ARRAY = 0b00000100;
-constexpr std::uint8_t TYPE_POSITIVE_INTEGER_BYTE = 0b00000101;
-constexpr std::uint8_t TYPE_NEGATIVE_INTEGER_BYTE = 0b00000110;
-constexpr std::uint8_t TYPE_OTHER = 0b00000111;
-static_assert(TYPE_SHARED_STRING <= sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_STRING <= sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_LONG_STRING <= sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_OBJECT <= sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_ARRAY <= sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_POSITIVE_INTEGER_BYTE <=
-              sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_NEGATIVE_INTEGER_BYTE <=
-              sourcemeta::core::uint_max<TYPE_SIZE>);
-static_assert(TYPE_OTHER <= sourcemeta::core::uint_max<TYPE_SIZE>);
-
-constexpr auto SUBTYPE_SIZE = 5;
-constexpr std::uint8_t SUBTYPE_FALSE = 0b00000000;
-constexpr std::uint8_t SUBTYPE_TRUE = 0b00000001;
-constexpr std::uint8_t SUBTYPE_NULL = 0b00000010;
-constexpr std::uint8_t SUBTYPE_POSITIVE_INTEGER = 0b00000011;
-constexpr std::uint8_t SUBTYPE_NEGATIVE_INTEGER = 0b00000100;
-constexpr std::uint8_t SUBTYPE_NUMBER = 0b00000101;
-constexpr std::uint8_t SUBTYPE_POSITIVE_REAL_INTEGER_BYTE = 0b00000110;
-constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_7 = 0b00000111;
-constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_8 = 0b00001000;
-constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_9 = 0b00001001;
-constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_10 = 0b00001010;
-constexpr std::uint8_t SUBTYPE_DECIMAL = 0b00001011;
-
-static_assert(SUBTYPE_FALSE <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_TRUE <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_NULL <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_POSITIVE_INTEGER <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_NEGATIVE_INTEGER <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_NUMBER <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_POSITIVE_REAL_INTEGER_BYTE <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_7 <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_8 <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_9 <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_10 <=
-              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-static_assert(SUBTYPE_DECIMAL <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
-
-// Note that the binary values actually match the declared exponents
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_7 == 7);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_8 == 8);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_9 == 9);
-static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_10 == 10);
-} // namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX
-#endif
-
-/// @}
-
-/// @ingroup runtime
-/// @defgroup encoding_string String Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consist in the UTF-8 encoding of the input string.
-///
-/// ### Options
-///
-/// | Option | Type   | Description                  |
-/// |--------|--------|------------------------------|
-/// | `size` | `uint` | The string UTF-8 byte-length |
-///
-/// ### Conditions
-///
-/// | Condition            | Description                                               |
-/// |----------------------|-----------------------------------------------------------|
-/// | `len(value) == size` | The input string must have the declared UTF-8 byte-length |
-///
-/// ### Examples
-///
-/// Given the input value "foo bar" with a corresponding size of 7, the encoding
-/// results in:
-///
-/// ```
-/// +------+------+------+------+------+------+------+
-/// | 0x66 | 0x6f | 0x6f | 0x20 | 0x62 | 0x61 | 0x72 |
-/// +------+------+------+------+------+------+------+
-///   f      o      o             b      a      r
-/// ```
-// clang-format on
-struct UTF8_STRING_NO_LENGTH {
-  /// The string UTF-8 byte-length
-  std::uint64_t size;
-};
-
-// clang-format off
-/// @brief The encoding consists of the byte-length of the string minus
-/// `minimum` plus 1 as a Base-128 64-bit Little Endian variable-length
-/// unsigned integer followed by the UTF-8 encoding of the input value.
-///
-/// Optionally, if the input string has already been encoded to the buffer
-/// using UTF-8, the encoding may consist of the byte constant `0x00` followed
-/// by the byte-length of the string minus `minimum` plus 1 as a Base-128
-/// 64-bit Little Endian variable-length unsigned integer, followed by the
-/// current offset minus the offset to the start of the UTF-8 string value in
-/// the buffer encoded as a Base-128 64-bit Little Endian variable-length
-/// unsigned integer.
-///
-/// #### Options
-///
-/// | Option    | Type   | Description                                    |
-/// |-----------|--------|------------------------------------------------|
-/// | `minimum` | `uint` | The inclusive minimum string UTF-8 byte-length |
-///
-/// #### Conditions
-///
-/// | Condition               | Description                                                          |
-/// |-------------------------|----------------------------------------------------------------------|
-/// | `len(value) >= minimum` | The input string byte-length is equal to or greater than the minimum |
-///
-/// #### Examples
-///
-/// Given the input string `foo` with a minimum 3 where the string has not been
-/// previously encoded, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x01 | 0x66 | 0x6f | 0x6f |
-/// +------+------+------+------+
-///          f      o      o
-/// ```
-///
-/// Given the encoding of `foo` with a minimum of 0 followed by the encoding of
-/// `foo` with a minimum of 3, the encoding may result in:
-///
-/// ```
-/// 0      1      2      3      4      5      6
-/// ^      ^      ^      ^      ^      ^      ^
-/// +------+------+------+------+------+------+------+
-/// | 0x04 | 0x66 | 0x6f | 0x6f | 0x00 | 0x01 | 0x05 |
-/// +------+------+------+------+------+------+------+
-///          f      o      o                    6 - 1
-/// ```
-// clang-format on
-struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED {
-  /// The inclusive minimum string UTF-8 byte-length
-  std::uint64_t minimum;
-};
-
-// clang-format off
-/// @brief The encoding consists of `maximum` minus the byte-length of the
-/// string plus 1 as a Base-128 64-bit Little Endian variable-length unsigned
-/// integer followed by the UTF-8 encoding of the input value.
-///
-/// Optionally, if the input string has already been encoded to the buffer
-/// using UTF-8, the encoding may consist of the byte constant `0x00` followed
-/// by `maximum` minus the byte-length of the string plus 1 as a Base-128
-/// 64-bit Little Endian variable-length unsigned integer, followed by the
-/// current offset minus the offset to the start of the UTF-8 string value in
-/// the buffer encoded as a Base-128 64-bit Little Endian variable-length
-/// unsigned integer.
-///
-/// #### Options
-///
-/// | Option    | Type   | Description                                    |
-/// |-----------|--------|------------------------------------------------|
-/// | `maximum` | `uint` | The inclusive maximum string UTF-8 byte-length |
-///
-/// #### Conditions
-///
-/// | Condition               | Description                                                       |
-/// |-------------------------|-------------------------------------------------------------------|
-/// | `len(value) <= maximum` | The input string byte-length is equal to or less than the maximum |
-///
-/// #### Examples
-///
-/// Given the input string `foo` with a maximum 4 where the string has not been
-/// previously encoded, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x02 | 0x66 | 0x6f | 0x6f |
-/// +------+------+------+------+
-///          f      o      o
-/// ```
-///
-/// Given the encoding of `foo` with a maximum of 3 followed by the encoding of
-/// `foo` with a maximum of 5, the encoding may result in:
-///
-/// ```
-/// 0      1      2      3      4      5      6
-/// ^      ^      ^      ^      ^      ^      ^
-/// +------+------+------+------+------+------+------+
-/// | 0x01 | 0x66 | 0x6f | 0x6f | 0x00 | 0x03 | 0x05 |
-/// +------+------+------+------+------+------+------+
-///          f      o      o                    6 - 1
-/// ```
-// clang-format on
-struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED {
-  /// The inclusive maximum string UTF-8 byte-length
-  std::uint64_t maximum;
-};
-
-// clang-format off
-/// @brief The encoding consists of the byte-length of the string minus
-/// `minimum` plus 1 as an 8-bit fixed-length unsigned integer followed by the
-/// UTF-8 encoding of the input value.
-///
-/// Optionally, if the input string has already been encoded to the buffer
-/// using UTF-8, the encoding may consist of the byte constant `0x00` followed
-/// by the byte-length of the string minus `minimum` plus 1 as an 8-bit
-/// fixed-length unsigned integer, followed by the current offset minus the
-/// offset to the start of the UTF-8 string value in the buffer encoded as a
-/// Base-128 64-bit Little Endian variable-length unsigned integer.
-///
-/// The byte-length of the string is encoded even if `maximum` equals `minimum`
-/// in order to disambiguate between shared and non-shared fixed strings.
-///
-/// #### Options
-///
-/// | Option    | Type   | Description                                    |
-/// |-----------|--------|------------------------------------------------|
-/// | `minimum` | `uint` | The inclusive minimum string UTF-8 byte-length |
-/// | `maximum` | `uint` | The inclusive maximum string UTF-8 byte-length |
-///
-/// #### Conditions
-///
-/// | Condition                        | Description                                                          |
-/// |----------------------------------|----------------------------------------------------------------------|
-/// | `len(value) >= minimum`          | The input string byte-length is equal to or greater than the minimum |
-/// | `len(value) <= maximum`          | The input string byte-length is equal to or less than the maximum    |
-/// | `maximum - minimum < 2 ** 8 - 1` | The range minus 1 must be representable in 8 bits                    |
-///
-/// #### Examples
-///
-/// Given the input string `foo` with a minimum 3 and a maximum 5 where the string
-/// has not been previously encoded, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x01 | 0x66 | 0x6f | 0x6f |
-/// +------+------+------+------+
-///          f      o      o
-/// ```
-///
-/// Given the encoding of `foo` with a minimum of 0 and a maximum of 6 followed by
-/// the encoding of `foo` with a minimum of 3 and a maximum of 100, the encoding
-/// may result in:
-///
-/// ```
-/// 0      1      2      3      4      5      6
-/// ^      ^      ^      ^      ^      ^      ^
-/// +------+------+------+------+------+------+------+
-/// | 0x04 | 0x66 | 0x6f | 0x6f | 0x00 | 0x01 | 0x05 |
-/// +------+------+------+------+------+------+------+
-///          f      o      o                    6 - 1
-/// ```
-// clang-format on
-struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED {
-  /// The inclusive minimum string UTF-8 byte-length
-  std::uint64_t minimum;
-  /// The inclusive maximum string UTF-8 byte-length
-  std::uint64_t maximum;
-};
-
-// clang-format off
-/// @brief The encoding consists of an implementation of
-/// [RFC3339](https://datatracker.ietf.org/doc/html/rfc3339) date expressions
-/// as the sequence of 3 integers: the year as a 16-bit fixed-length Little
-/// Endian unsigned integer, the month as an 8-bit fixed-length unsigned
-/// integer, and the day as an 8-bit fixed-length unsigned integer.
-///
-/// #### Options
-///
-/// None
-///
-/// #### Conditions
-///
-/// | Condition            | Description                                                 |
-/// |----------------------|-------------------------------------------------------------|
-/// | `len(value) == 10`   | The input string consists of 10 characters                  |
-/// | `value[0:4] >= 0`    | The year is greater than or equal to 0                      |
-/// | `value[0:4] <= 9999` | The year is less than or equal to 9999 as stated by RFC3339 |
-/// | `value[4] == "-"`    | The year and the month are divided by a hyphen              |
-/// | `value[5:7] >= 1`    | The month is greater than or equal to 1                     |
-/// | `value[5:7] <= 12`   | The month is less than or equal to 12                       |
-/// | `value[7] == "-"`    | The month and the day are divided by a hyphen               |
-/// | `value[8:10] >= 1`   | The day is greater than or equal to 1                       |
-/// | `value[8:10] <= 31`  | The day is less than or equal to 31                         |
-///
-/// #### Examples
-///
-/// Given the input string `2014-10-01`, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0xde | 0x07 | 0x0a | 0x01 |
-/// +------+------+------+------+
-///   year   ...    month  day
-/// ```
-// clang-format on
-struct RFC3339_DATE_INTEGER_TRIPLET {};
-
-// clang-format off
-/// @brief The encoding consists of the byte-length of the string plus 1 as a
-/// Base-128 64-bit Little Endian variable-length unsigned integer followed by
-/// the UTF-8 encoding of the input value.
-///
-/// Optionally, if the input string has already been encoded to the buffer
-/// using this encoding the encoding may consist of the byte constant `0x00`
-/// followed by the current offset minus the offset to the start of the string
-/// as a Base-128 64-bit Little Endian variable-length unsigned integer.  It is
-/// permissible to point to another instance of the string that is a pointer
-/// itself.
-///
-/// ### Options
-///
-/// None
-///
-/// ### Conditions
-///
-/// None
-///
-/// ### Examples
-///
-/// Given the input string `foo` where the string has not been previously encoded,
-/// the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x04 | 0x66 | 0x6f | 0x6f |
-/// +------+------+------+------+
-///          f      o      o
-/// ```
-///
-/// Given the encoding of `foo` repeated 3 times, the encoding may result in:
-///
-/// ```
-/// 0      1      2      3      4      5      6      7
-/// ^      ^      ^      ^      ^      ^      ^      ^
-/// +------+------+------+------+------+------+------+------+
-/// | 0x04 | 0x66 | 0x6f | 0x6f | 0x00 | 0x05 | 0x00 | 0x03 |
-/// +------+------+------+------+------+------+------+------+
-///          f      o      o             5 - 0         7 - 4
-/// ```
-// clang-format on
-struct PREFIX_VARINT_LENGTH_STRING_SHARED {};
-
-/// @}
-
-/// @ingroup runtime
-/// @defgroup encoding_array Array Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consists of the elements of the fixed array encoded in
-/// order. The encoding of the element at index `i` is either
-/// `prefix_encodings[i]` if set, or `encoding`.
-///
-/// ### Options
-///
-/// | Option            | Type         | Description          |
-/// |-------------------|--------------|----------------------|
-/// | `size`            | `uint`       | The array length     |
-/// | `prefixEncodings` | `encoding[]` | Positional encodings |
-/// | `encoding`        | `encoding`   | Element encoding     |
-///
-/// ### Conditions
-///
-/// | Condition                      | Description                                                           |
-/// |--------------------------------|-----------------------------------------------------------------------|
-/// | `len(prefixEncodings) <= size` | The number of prefix encodings must be less than or equal to the size |
-/// | `len(value) == size`           | The input array must have the declared size                           |
-///
-/// ### Examples
-///
-/// Given the array `[ 1, 2, true ]` where the `prefixEncodings` corresponds to
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED (minimum 0, maximum 10, multiplier 1) and
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED (minimum 0, maximum 10, multiplier 1) and
-/// `encoding` corresponds to BYTE_CHOICE_INDEX with choices `[ false, true ]`,
-/// the encoding results in:
-///
-/// ```
-/// +------+------+------+
-/// | 0x00 | 0x01 | 0x01 |
-/// +------+------+------+
-///   1      2      true
-/// ```
-// clang-format on
-struct FIXED_TYPED_ARRAY {
-  /// The array length
-  std::uint64_t size;
-  /// Element encoding
-  std::shared_ptr<Encoding> encoding;
-  /// Positional encodings
-  std::vector<Encoding> prefix_encodings;
-};
-
-// clang-format off
-/// @brief The encoding consists of the length of the array minus `minimum`
-/// encoded as an 8-bit fixed-length unsigned integer followed by the elements
-/// of the array encoded in order. The encoding of the element at index `i` is
-/// either `prefix_encodings[i]` if set, or `encoding`.
-///
-/// ### Options
-///
-/// | Option            | Type         | Description                     |
-/// |-------------------|--------------|---------------------------------|
-/// | `minimum`         | `uint`       | The minimum length of the array |
-/// | `maximum`         | `uint`       | The maximum length of the array |
-/// | `prefixEncodings` | `encoding[]` | Positional encodings            |
-/// | `encoding`        | `encoding`   | Element encoding                |
-///
-/// ### Conditions
-///
-/// | Condition                              | Description                                                                           |
-/// |----------------------------------------|---------------------------------------------------------------------------------------|
-/// | `len(value) >= minimum`                | The length of the array must be greater than or equal to the minimum                  |
-/// | `len(value) <= maximum`                | The length of the array must be less than or equal to the maximum                     |
-/// | `len(prefixEncodings) <= maximum`      | The number of prefix encodings must be less than or equal to the maximum array length |
-/// | `len(maximum) - len(minimum) < 2 ** 8` | The array length must be representable in 8 bits                                      |
-///
-/// ### Examples
-///
-/// Given the array `[ true, false, 5 ]` where the minimum is 1 and the maximum is
-/// 3, the `prefixEncodings` corresponds to BYTE_CHOICE_INDEX with
-/// choices `[ false, true ]` and BYTE_CHOICE_INDEX with choices `[
-/// false, true ]` and `encoding` corresponds to
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED with minimum 0 and maximum
-/// 255, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x02 | 0x01 | 0x00 | 0x05 |
-/// +------+------+------+------+
-///   size   true   false  5
-/// ```
-// clang-format on
-struct BOUNDED_8BITS_TYPED_ARRAY {
-  /// The minimum length of the array
-  std::uint64_t minimum;
-  /// The maximum length of the array
-  std::uint64_t maximum;
-  /// Element encoding
-  std::shared_ptr<Encoding> encoding;
-  /// Positional encodings
-  std::vector<Encoding> prefix_encodings;
-};
-
-// clang-format off
-/// @brief The encoding consists of the length of the array minus `minimum`
-/// encoded as a Base-128 64-bit Little Endian variable-length unsigned integer
-/// followed by the elements of the array encoded in order. The encoding of the
-/// element at index `i` is either `prefix_encodings[i]` if set, or `encoding`.
-///
-/// ### Options
-///
-/// | Option            | Type         | Description                     |
-/// |-------------------|--------------|---------------------------------|
-/// | `minimum`         | `uint`       | The minimum length of the array |
-/// | `prefixEncodings` | `encoding[]` | Positional encodings            |
-/// | `encoding`        | `encoding`   | Element encoding                |
-///
-/// ### Conditions
-///
-/// | Condition               | Description                                                          |
-/// |-------------------------|----------------------------------------------------------------------|
-/// | `len(value) >= minimum` | The length of the array must be greater than or equal to the minimum |
-///
-/// ### Examples
-///
-/// TODO: Give an example of an array with more than 8-bit of elements
-///
-/// Given the array `[ true, false, 5 ]` where the minimum is 1, the
-/// `prefixEncodings` corresponds to BYTE_CHOICE_INDEX with choices `[
-/// false, true ]` and BYTE_CHOICE_INDEX with choices `[ false, true ]`
-/// and `encoding` corresponds to BOUNDED_MULTIPLE_8BITS_ENUM_FIXED
-/// with minimum 0 and maximum 255, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x02 | 0x01 | 0x00 | 0x05 |
-/// +------+------+------+------+
-///   size   true   false  5
-/// ```
-// clang-format on
-struct FLOOR_TYPED_ARRAY {
-  /// The minimum length of the array
-  std::uint64_t minimum;
-  /// Element encoding
-  std::shared_ptr<Encoding> encoding;
-  /// Positional encodings
-  std::vector<Encoding> prefix_encodings;
-};
-
-// clang-format off
-/// @brief The encoding consists of `maximum` minus the length of the array
-/// encoded as a Base-128 64-bit Little Endian variable-length unsigned integer
-/// followed by the elements of the array encoded in order. The encoding of the
-/// element at index `i` is either `prefix_encodings[i]` if set, or `encoding`.
-///
-/// ### Options
-///
-/// | Option            | Type         | Description                     |
-/// |-------------------|--------------|---------------------------------|
-/// | `maximum`         | `uint`       | The maximum length of the array |
-/// | `prefixEncodings` | `encoding[]` | Positional encodings            |
-/// | `encoding`        | `encoding`   | Element encoding                |
-///
-/// ### Conditions
-///
-/// | Condition                         | Description                                                                           |
-/// |-----------------------------------|---------------------------------------------------------------------------------------|
-/// | `len(prefixEncodings) <= maximum` | The number of prefix encodings must be less than or equal to the maximum array length |
-///
-/// ### Examples
-///
-/// Given the array `[ true, false, 5 ]` where the maximum is 3, the
-/// `prefixEncodings` options corresponds to BYTE_CHOICE_INDEX with
-/// choices `[ false, true ]` and BYTE_CHOICE_INDEX with choices `[
-/// false, true ]` and `encoding` corresponds to
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED with minimum 0 and maximum
-/// 255, the encoding results in:
-///
-/// ```
-/// +------+------+------+------+
-/// | 0x00 | 0x01 | 0x00 | 0x05 |
-/// +------+------+------+------+
-///   size   true   false  5
-/// ```
-// clang-format on
-struct ROOF_TYPED_ARRAY {
-  /// The maximum length of the array
-  std::uint64_t maximum;
-  /// Element encoding
-  std::shared_ptr<Encoding> encoding;
-  /// Positional encodings
-  std::vector<Encoding> prefix_encodings;
-};
-
-/// @}
-
-/// @ingroup runtime
-/// @defgroup encoding_object Object Encodings
-/// @{
-
-// clang-format off
-/// @brief The encoding consists of each pair encoded as the key followed by
-/// the value according to `key_encoding` and `encoding`. The order in which
-/// pairs are encoded is undefined.
-///
-/// ### Options
-///
-/// | Option        | Type       | Description     |
-/// |---------------|------------|-----------------|
-/// | `size`        | `uint`     | The object size |
-/// | `keyEncoding` | `encoding` | Key encoding    |
-/// | `encoding`    | `encoding` | Value encoding  |
-///
-/// ### Conditions
-///
-/// | Condition            | Description                                               |
-/// |----------------------|-----------------------------------------------------------|
-/// | `len(value) == size` | The input object must have the declared amount of entries |
-///
-/// ### Examples
-///
-/// Given the array `{ "foo": 1, "bar": 2 }` where `keyEncoding` corresponds to
-/// UTF8_STRING_NO_LENGTH (size 3) and `encoding` corresponds to
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED (minimum 0, maximum 10,
-/// multiplier 1), the encoding results in:
-///
-/// ```
-/// +------+------+------+------+------+------+------+------+
-/// | 0x66 | 0x6f | 0x6f | 0x01 | 0x62 | 0x61 | 0x72 | 0x02 |
-/// +------+------+------+------+------+------+------+------+
-///   f      o      o      1      b      a      r      2
-/// ```
-///
-/// Or:
-///
-/// ```
-/// +------+------+------+------+------+------+------+------+
-/// | 0x62 | 0x61 | 0x72 | 0x02 | 0x66 | 0x6f | 0x6f | 0x01 |
-/// +------+------+------+------+------+------+------+------+
-///   b      a      r      2      f      o      o      1
-/// ```
-// clang-format on
-struct FIXED_TYPED_ARBITRARY_OBJECT {
-  /// The object size
-  std::uint64_t size;
-  /// Key encoding
-  std::shared_ptr<Encoding> key_encoding;
-  /// Value encoding
-  std::shared_ptr<Encoding> encoding;
-};
-
-// clang-format off
-/// @brief The encoding consists of the number of key-value pairs in the input
-/// object as a Base-128 64-bit Little Endian variable-length unsigned integer
-/// followed by each pair encoded as the key followed by the value according to
-/// `key_encoding` and `encoding`. The order in which pairs are encoded is
-/// undefined.
-///
-/// ### Options
-///
-/// | Option        | Type       | Description    |
-/// |---------------|------------|----------------|
-/// | `keyEncoding` | `encoding` | Key encoding   |
-/// | `encoding`    | `encoding` | Value encoding |
-///
-/// ### Examples
-///
-/// Given the array `{ "foo": 1, "bar": 2 }` where `keyEncoding` corresponds to
-/// UTF8_STRING_NO_LENGTH (size 3) and `encoding` corresponds to
-/// BOUNDED_MULTIPLE_8BITS_ENUM_FIXED (minimum 0, maximum 10,
-/// multiplier 1), the encoding results in:
-///
-/// ```
-/// +------+------+------+------+------+------+------+------+------+
-/// | 0x02 | 0x66 | 0x6f | 0x6f | 0x01 | 0x62 | 0x61 | 0x72 | 0x02 |
-/// +------+------+------+------+------+------+------+------+------+
-///   2      f      o      o      1      b      a      r      2
-/// ```
-///
-/// Or:
-///
-/// ```
-/// +------+------+------+------+------+------+------+------+------+
-/// | 0x02 | 0x62 | 0x61 | 0x72 | 0x02 | 0x66 | 0x6f | 0x6f | 0x01 |
-/// +------+------+------+------+------+------+------+------+------+
-///   2      b      a      r      2      f      o      o      1
-/// ```
-// clang-format on
-struct VARINT_TYPED_ARBITRARY_OBJECT {
-  /// Key encoding
-  std::shared_ptr<Encoding> key_encoding;
-  /// Value encoding
-  std::shared_ptr<Encoding> encoding;
-};
-
-/// @}
-
-// NOLINTEND(readability-identifier-naming)
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_input_stream.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_input_stream.h
deleted file mode 100644
index ee9d4bac9..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_input_stream.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_INPUT_STREAM_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_INPUT_STREAM_H_
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/core/io.h>
-#include <sourcemeta/core/json.h>
-
-#include <cstdint> // std::uint64_t, std::int64_t
-#include <istream> // std::basic_istream
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup runtime
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT InputStream
-    : public sourcemeta::core::BinaryReader {
-public:
-  using Stream = std::basic_istream<sourcemeta::core::JSON::Char,
-                                    sourcemeta::core::JSON::CharTraits>;
-  InputStream(Stream &input);
-
-  // Seek backwards given a relative offset
-  auto rewind(const std::uint64_t relative_offset, const std::uint64_t position)
-      -> std::uint64_t;
-  auto get_varint() -> std::uint64_t;
-  auto get_varint_zigzag() -> std::int64_t;
-  auto get_string_utf8(const std::uint64_t length)
-      -> sourcemeta::core::JSON::String;
-};
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_output_stream.h b/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_output_stream.h
deleted file mode 100644
index 3207d66b6..000000000
--- a/vendor/jsonbinpack/src/runtime/include/sourcemeta/jsonbinpack/runtime_output_stream.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_OUTPUT_STREAM_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_OUTPUT_STREAM_H_
-
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT
-#include <sourcemeta/jsonbinpack/runtime_export.h>
-#endif
-
-#include <sourcemeta/core/io.h>
-#include <sourcemeta/core/json.h>
-
-#include <cstdint> // std::uint64_t, std::int64_t
-#include <ostream> // std::basic_ostream
-
-namespace sourcemeta::jsonbinpack {
-
-/// @ingroup runtime
-class SOURCEMETA_JSONBINPACK_RUNTIME_EXPORT OutputStream
-    : public sourcemeta::core::BinaryWriter {
-public:
-  using Stream = std::basic_ostream<sourcemeta::core::JSON::Char,
-                                    sourcemeta::core::JSON::CharTraits>;
-  OutputStream(Stream &output);
-
-  auto put_varint(const std::uint64_t value) -> void;
-  auto put_varint_zigzag(const std::int64_t value) -> void;
-  auto put_string_utf8(const sourcemeta::core::JSON::String &string,
-                       const std::uint64_t length) -> void;
-};
-
-} // namespace sourcemeta::jsonbinpack
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/input_stream.cc b/vendor/jsonbinpack/src/runtime/input_stream.cc
deleted file mode 100644
index f98ed5af7..000000000
--- a/vendor/jsonbinpack/src/runtime/input_stream.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_input_stream.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstddef> // std::size_t
-#include <cstdint> // std::uint8_t, std::uint64_t, std::int64_t
-
-namespace sourcemeta::jsonbinpack {
-
-InputStream::InputStream(Stream &input)
-    : sourcemeta::core::BinaryReader{input} {}
-
-auto InputStream::rewind(const std::uint64_t relative_offset,
-                         const std::uint64_t position) -> std::uint64_t {
-  assert(position >= relative_offset);
-  const std::uint64_t offset{position - relative_offset};
-  assert(offset < position);
-  const std::uint64_t current{this->position()};
-  this->seek(offset);
-  return current;
-}
-
-auto InputStream::get_varint() -> std::uint64_t {
-  constexpr std::uint8_t LEAST_SIGNIFICANT_BITS{0b01111111};
-  constexpr std::uint8_t MOST_SIGNIFICANT_BIT{0b10000000};
-  constexpr std::uint8_t SHIFT{7};
-  std::uint64_t result{0};
-  std::size_t cursor{0};
-  while (true) {
-    const std::uint8_t byte{this->get_byte()};
-    const std::uint64_t value{
-        static_cast<std::uint64_t>(byte & LEAST_SIGNIFICANT_BITS)};
-#ifndef NDEBUG
-    const std::uint64_t current = result;
-#endif
-    result += static_cast<std::uint64_t>(value << SHIFT * cursor);
-    // Try to catch potential overflows from the above addition
-    assert(result >= current);
-    cursor += 1;
-    if ((byte & MOST_SIGNIFICANT_BIT) == 0) {
-      break;
-    }
-  }
-
-  return result;
-}
-
-auto InputStream::get_varint_zigzag() -> std::int64_t {
-  return sourcemeta::core::zigzag_decode(this->get_varint());
-}
-
-auto InputStream::get_string_utf8(const std::uint64_t length)
-    -> sourcemeta::core::JSON::String {
-  sourcemeta::core::JSON::String result;
-  result.reserve(length);
-  std::uint64_t counter = 0;
-  while (counter < length) {
-    result += static_cast<sourcemeta::core::JSON::Char>(this->get_byte());
-    counter += 1;
-  }
-
-  assert(counter == length);
-  assert(result.size() == length);
-  return result;
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/loader.cc b/vendor/jsonbinpack/src/runtime/loader.cc
deleted file mode 100644
index d340da362..000000000
--- a/vendor/jsonbinpack/src/runtime/loader.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include "loader_v1_any.h"
-#include "loader_v1_array.h"
-#include "loader_v1_integer.h"
-#include "loader_v1_number.h"
-#include "loader_v1_string.h"
-
-#include <cassert>   // assert
-#include <sstream>   // std::ostringstream
-#include <stdexcept> // std::runtime_error
-
-namespace sourcemeta::jsonbinpack {
-
-auto load(const sourcemeta::core::JSON &input) -> Encoding {
-  assert(input.defines("binpackEncoding"));
-  assert(input.defines("binpackOptions"));
-  const auto encoding{input.at("binpackEncoding").to_string()};
-  const auto &options{input.at("binpackOptions")};
-
-#define PARSE_ENCODING(version, name)                                          \
-  if (encoding == #name)                                                       \
-    return version::name(options);
-
-  // Integers
-  PARSE_ENCODING(v1, BOUNDED_MULTIPLE_8BITS_ENUM_FIXED)
-  PARSE_ENCODING(v1, FLOOR_MULTIPLE_ENUM_VARINT)
-  PARSE_ENCODING(v1, ROOF_MULTIPLE_MIRROR_ENUM_VARINT)
-  PARSE_ENCODING(v1, ARBITRARY_MULTIPLE_ZIGZAG_VARINT)
-  // Numbers
-  PARSE_ENCODING(v1, DOUBLE_VARINT_TUPLE)
-  PARSE_ENCODING(v1, NUMBER_VARINT_TUPLE)
-  // Any
-  PARSE_ENCODING(v1, BYTE_CHOICE_INDEX)
-  PARSE_ENCODING(v1, LARGE_CHOICE_INDEX)
-  PARSE_ENCODING(v1, TOP_LEVEL_BYTE_CHOICE_INDEX)
-  PARSE_ENCODING(v1, CONST_NONE)
-  PARSE_ENCODING(v1, ANY_PACKED_TYPE_TAG_BYTE_PREFIX)
-  // Strings
-  PARSE_ENCODING(v1, UTF8_STRING_NO_LENGTH)
-  PARSE_ENCODING(v1, FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED)
-  PARSE_ENCODING(v1, ROOF_VARINT_PREFIX_UTF8_STRING_SHARED)
-  PARSE_ENCODING(v1, BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED)
-  PARSE_ENCODING(v1, RFC3339_DATE_INTEGER_TRIPLET)
-  PARSE_ENCODING(v1, PREFIX_VARINT_LENGTH_STRING_SHARED)
-  // Arrays
-  PARSE_ENCODING(v1, FIXED_TYPED_ARRAY)
-  PARSE_ENCODING(v1, BOUNDED_8BITS_TYPED_ARRAY)
-  PARSE_ENCODING(v1, FLOOR_TYPED_ARRAY)
-  PARSE_ENCODING(v1, ROOF_TYPED_ARRAY)
-
-  // TODO: Handle object encodings
-
-#undef PARSE_ENCODING
-
-  std::ostringstream error;
-  error << "Unrecognized encoding: " << encoding;
-  throw EncodingError(error.str());
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/loader_v1_any.h b/vendor/jsonbinpack/src/runtime/loader_v1_any.h
deleted file mode 100644
index a0b855ae7..000000000
--- a/vendor/jsonbinpack/src/runtime/loader_v1_any.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ANY_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ANY_H_
-
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include <sourcemeta/core/json.h>
-
-#include <cassert> // assert
-#include <utility> // std::move
-#include <vector>  // std::vector
-
-namespace sourcemeta::jsonbinpack::v1 {
-
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-auto BYTE_CHOICE_INDEX(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("choices"));
-  const auto &choices{options.at("choices")};
-  assert(choices.is_array());
-  const auto &array{choices.as_array()};
-  std::vector<sourcemeta::core::JSON> elements{array.cbegin(), array.cend()};
-  return sourcemeta::jsonbinpack::BYTE_CHOICE_INDEX{.choices =
-                                                        std::move(elements)};
-}
-
-auto LARGE_CHOICE_INDEX(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("choices"));
-  const auto &choices{options.at("choices")};
-  assert(choices.is_array());
-  const auto &array{choices.as_array()};
-  std::vector<sourcemeta::core::JSON> elements{array.cbegin(), array.cend()};
-  return sourcemeta::jsonbinpack::LARGE_CHOICE_INDEX{.choices =
-                                                         std::move(elements)};
-}
-
-auto TOP_LEVEL_BYTE_CHOICE_INDEX(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("choices"));
-  const auto &choices{options.at("choices")};
-  assert(choices.is_array());
-  const auto &array{choices.as_array()};
-  std::vector<sourcemeta::core::JSON> elements{array.cbegin(), array.cend()};
-  return sourcemeta::jsonbinpack::TOP_LEVEL_BYTE_CHOICE_INDEX{
-      .choices = std::move(elements)};
-}
-
-auto CONST_NONE(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("value"));
-  return sourcemeta::jsonbinpack::CONST_NONE{.value = options.at("value")};
-}
-
-auto ANY_PACKED_TYPE_TAG_BYTE_PREFIX(
-    [[maybe_unused]] const sourcemeta::core::JSON &options) -> Encoding {
-  return sourcemeta::jsonbinpack::ANY_PACKED_TYPE_TAG_BYTE_PREFIX{};
-}
-
-// NOLINTEND(readability-identifier-naming)
-} // namespace sourcemeta::jsonbinpack::v1
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/loader_v1_array.h b/vendor/jsonbinpack/src/runtime/loader_v1_array.h
deleted file mode 100644
index 39e55d3a7..000000000
--- a/vendor/jsonbinpack/src/runtime/loader_v1_array.h
+++ /dev/null
@@ -1,122 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ARRAY_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ARRAY_H_
-
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include <sourcemeta/core/json.h>
-
-#include <algorithm> // std::transform
-#include <cassert>   // assert
-#include <cstdint>   // std::uint64_t
-#include <iterator>  // std::back_inserter
-#include <memory>    // std::make_shared
-#include <vector>    // std::vector
-
-namespace sourcemeta::jsonbinpack::v1 {
-
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-auto FIXED_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("size"));
-  assert(options.defines("encoding"));
-  assert(options.defines("prefixEncodings"));
-  const auto &size{options.at("size")};
-  const auto &array_encoding{options.at("encoding")};
-  const auto &prefix_encodings{options.at("prefixEncodings")};
-  assert(size.is_integer());
-  assert(size.is_positive());
-  assert(array_encoding.is_object());
-  assert(prefix_encodings.is_array());
-  std::vector<Encoding> encodings;
-  std::transform(prefix_encodings.as_array().cbegin(),
-                 prefix_encodings.as_array().cend(),
-                 std::back_inserter(encodings),
-                 [](const auto &element) -> Encoding { return load(element); });
-  assert(encodings.size() == prefix_encodings.size());
-  return sourcemeta::jsonbinpack::FIXED_TYPED_ARRAY{
-      .size = static_cast<std::uint64_t>(size.to_integer()),
-      .encoding = std::make_shared<Encoding>(load(array_encoding)),
-      .prefix_encodings = std::move(encodings)};
-}
-
-auto BOUNDED_8BITS_TYPED_ARRAY(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("minimum"));
-  assert(options.defines("maximum"));
-  assert(options.defines("encoding"));
-  assert(options.defines("prefixEncodings"));
-  const auto &minimum{options.at("minimum")};
-  const auto &maximum{options.at("maximum")};
-  const auto &array_encoding{options.at("encoding")};
-  const auto &prefix_encodings{options.at("prefixEncodings")};
-  assert(minimum.is_integer());
-  assert(maximum.is_integer());
-  assert(minimum.is_positive());
-  assert(maximum.is_positive());
-  assert(array_encoding.is_object());
-  assert(prefix_encodings.is_array());
-  std::vector<Encoding> encodings;
-  std::transform(prefix_encodings.as_array().cbegin(),
-                 prefix_encodings.as_array().cend(),
-                 std::back_inserter(encodings),
-                 [](const auto &element) -> Encoding { return load(element); });
-  assert(encodings.size() == prefix_encodings.size());
-  return sourcemeta::jsonbinpack::BOUNDED_8BITS_TYPED_ARRAY{
-      .minimum = static_cast<std::uint64_t>(minimum.to_integer()),
-      .maximum = static_cast<std::uint64_t>(maximum.to_integer()),
-      .encoding = std::make_shared<Encoding>(load(array_encoding)),
-      .prefix_encodings = std::move(encodings)};
-}
-
-auto FLOOR_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("minimum"));
-  assert(options.defines("encoding"));
-  assert(options.defines("prefixEncodings"));
-  const auto &minimum{options.at("minimum")};
-  const auto &array_encoding{options.at("encoding")};
-  const auto &prefix_encodings{options.at("prefixEncodings")};
-  assert(minimum.is_integer());
-  assert(minimum.is_positive());
-  assert(array_encoding.is_object());
-  assert(prefix_encodings.is_array());
-  std::vector<Encoding> encodings;
-  std::transform(prefix_encodings.as_array().cbegin(),
-                 prefix_encodings.as_array().cend(),
-                 std::back_inserter(encodings),
-                 [](const auto &element) -> Encoding { return load(element); });
-  assert(encodings.size() == prefix_encodings.size());
-  return sourcemeta::jsonbinpack::FLOOR_TYPED_ARRAY{
-      .minimum = static_cast<std::uint64_t>(minimum.to_integer()),
-      .encoding = std::make_shared<Encoding>(load(array_encoding)),
-      .prefix_encodings = std::move(encodings)};
-}
-
-auto ROOF_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("maximum"));
-  assert(options.defines("encoding"));
-  assert(options.defines("prefixEncodings"));
-  const auto &maximum{options.at("maximum")};
-  const auto &array_encoding{options.at("encoding")};
-  const auto &prefix_encodings{options.at("prefixEncodings")};
-  assert(maximum.is_integer());
-  assert(maximum.is_positive());
-  assert(array_encoding.is_object());
-  assert(prefix_encodings.is_array());
-  std::vector<Encoding> encodings;
-  std::transform(prefix_encodings.as_array().cbegin(),
-                 prefix_encodings.as_array().cend(),
-                 std::back_inserter(encodings),
-                 [](const auto &element) -> Encoding { return load(element); });
-  assert(encodings.size() == prefix_encodings.size());
-  return sourcemeta::jsonbinpack::ROOF_TYPED_ARRAY{
-      .maximum = static_cast<std::uint64_t>(maximum.to_integer()),
-      .encoding = std::make_shared<Encoding>(load(array_encoding)),
-      .prefix_encodings = std::move(encodings)};
-}
-
-// NOLINTEND(readability-identifier-naming)
-} // namespace sourcemeta::jsonbinpack::v1
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/loader_v1_integer.h b/vendor/jsonbinpack/src/runtime/loader_v1_integer.h
deleted file mode 100644
index 6c6e707c8..000000000
--- a/vendor/jsonbinpack/src/runtime/loader_v1_integer.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_INTEGER_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_INTEGER_H_
-
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include <sourcemeta/core/json.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint64_t
-
-namespace sourcemeta::jsonbinpack::v1 {
-
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-auto BOUNDED_MULTIPLE_8BITS_ENUM_FIXED(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("minimum"));
-  assert(options.defines("maximum"));
-  assert(options.defines("multiplier"));
-  const auto &minimum{options.at("minimum")};
-  const auto &maximum{options.at("maximum")};
-  const auto &multiplier{options.at("multiplier")};
-  assert(minimum.is_integer());
-  assert(maximum.is_integer());
-  assert(multiplier.is_integer());
-  assert(multiplier.is_positive());
-  return sourcemeta::jsonbinpack::BOUNDED_MULTIPLE_8BITS_ENUM_FIXED{
-      .minimum = minimum.to_integer(),
-      .maximum = maximum.to_integer(),
-      .multiplier = static_cast<std::uint64_t>(multiplier.to_integer())};
-}
-
-auto FLOOR_MULTIPLE_ENUM_VARINT(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("minimum"));
-  assert(options.defines("multiplier"));
-  const auto &minimum{options.at("minimum")};
-  const auto &multiplier{options.at("multiplier")};
-  assert(minimum.is_integer());
-  assert(multiplier.is_integer());
-  assert(multiplier.is_positive());
-  return sourcemeta::jsonbinpack::FLOOR_MULTIPLE_ENUM_VARINT{
-      .minimum = minimum.to_integer(),
-      .multiplier = static_cast<std::uint64_t>(multiplier.to_integer())};
-}
-
-auto ROOF_MULTIPLE_MIRROR_ENUM_VARINT(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("maximum"));
-  assert(options.defines("multiplier"));
-  const auto &maximum{options.at("maximum")};
-  const auto &multiplier{options.at("multiplier")};
-  assert(maximum.is_integer());
-  assert(multiplier.is_integer());
-  assert(multiplier.is_positive());
-  return sourcemeta::jsonbinpack::ROOF_MULTIPLE_MIRROR_ENUM_VARINT{
-      .maximum = maximum.to_integer(),
-      .multiplier = static_cast<std::uint64_t>(multiplier.to_integer())};
-}
-
-auto ARBITRARY_MULTIPLE_ZIGZAG_VARINT(const sourcemeta::core::JSON &options)
-    -> Encoding {
-  assert(options.defines("multiplier"));
-  const auto &multiplier{options.at("multiplier")};
-  assert(multiplier.is_integer());
-  assert(multiplier.is_positive());
-  return sourcemeta::jsonbinpack::ARBITRARY_MULTIPLE_ZIGZAG_VARINT{
-      .multiplier = static_cast<std::uint64_t>(multiplier.to_integer())};
-}
-
-// NOLINTEND(readability-identifier-naming)
-} // namespace sourcemeta::jsonbinpack::v1
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/loader_v1_number.h b/vendor/jsonbinpack/src/runtime/loader_v1_number.h
deleted file mode 100644
index b7582c08c..000000000
--- a/vendor/jsonbinpack/src/runtime/loader_v1_number.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_NUMBER_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_NUMBER_H_
-
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include <sourcemeta/core/json.h>
-
-namespace sourcemeta::jsonbinpack::v1 {
-
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-auto DOUBLE_VARINT_TUPLE([[maybe_unused]] const sourcemeta::core::JSON &options)
-    -> Encoding {
-  return sourcemeta::jsonbinpack::DOUBLE_VARINT_TUPLE{};
-}
-
-auto NUMBER_VARINT_TUPLE([[maybe_unused]] const sourcemeta::core::JSON &options)
-    -> Encoding {
-  return sourcemeta::jsonbinpack::NUMBER_VARINT_TUPLE{};
-}
-
-// NOLINTEND(readability-identifier-naming)
-} // namespace sourcemeta::jsonbinpack::v1
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/loader_v1_string.h b/vendor/jsonbinpack/src/runtime/loader_v1_string.h
deleted file mode 100644
index 1413c1d5a..000000000
--- a/vendor/jsonbinpack/src/runtime/loader_v1_string.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_STRING_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_STRING_H_
-
-#include <sourcemeta/jsonbinpack/runtime.h>
-
-#include <sourcemeta/core/json.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint64_t
-
-namespace sourcemeta::jsonbinpack::v1 {
-
-// The encoding names are the ones the JSON BinPack specification defines, so
-// they keep their casing rather than following the C++ naming convention
-// NOLINTBEGIN(readability-identifier-naming)
-
-auto UTF8_STRING_NO_LENGTH(const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("size"));
-  const auto &size{options.at("size")};
-  assert(size.is_integer());
-  assert(size.is_positive());
-  return sourcemeta::jsonbinpack::UTF8_STRING_NO_LENGTH{
-      .size = static_cast<std::uint64_t>(size.to_integer())};
-}
-
-auto FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("minimum"));
-  const auto &minimum{options.at("minimum")};
-  assert(minimum.is_integer());
-  assert(minimum.is_positive());
-  return sourcemeta::jsonbinpack::FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED{
-      .minimum = static_cast<std::uint64_t>(minimum.to_integer())};
-}
-
-auto ROOF_VARINT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("maximum"));
-  const auto &maximum{options.at("maximum")};
-  assert(maximum.is_integer());
-  assert(maximum.is_positive());
-  return sourcemeta::jsonbinpack::ROOF_VARINT_PREFIX_UTF8_STRING_SHARED{
-      .maximum = static_cast<std::uint64_t>(maximum.to_integer())};
-}
-
-auto BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED(
-    const sourcemeta::core::JSON &options) -> Encoding {
-  assert(options.defines("minimum"));
-  assert(options.defines("maximum"));
-  const auto &minimum{options.at("minimum")};
-  const auto &maximum{options.at("maximum")};
-  assert(minimum.is_integer());
-  assert(maximum.is_integer());
-  assert(minimum.is_positive());
-  assert(maximum.is_positive());
-  return sourcemeta::jsonbinpack::BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED{
-      .minimum = static_cast<std::uint64_t>(minimum.to_integer()),
-      .maximum = static_cast<std::uint64_t>(maximum.to_integer())};
-}
-
-auto RFC3339_DATE_INTEGER_TRIPLET(
-    [[maybe_unused]] const sourcemeta::core::JSON &options) -> Encoding {
-  return sourcemeta::jsonbinpack::RFC3339_DATE_INTEGER_TRIPLET{};
-}
-
-auto PREFIX_VARINT_LENGTH_STRING_SHARED(
-    [[maybe_unused]] const sourcemeta::core::JSON &options) -> Encoding {
-  return sourcemeta::jsonbinpack::PREFIX_VARINT_LENGTH_STRING_SHARED{};
-}
-
-// NOLINTEND(readability-identifier-naming)
-} // namespace sourcemeta::jsonbinpack::v1
-
-#endif
diff --git a/vendor/jsonbinpack/src/runtime/output_stream.cc b/vendor/jsonbinpack/src/runtime/output_stream.cc
deleted file mode 100644
index b95789b9f..000000000
--- a/vendor/jsonbinpack/src/runtime/output_stream.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <sourcemeta/jsonbinpack/runtime_output_stream.h>
-
-#include <sourcemeta/core/numeric.h>
-
-#include <cassert> // assert
-#include <cstdint> // std::uint8_t, std::uint64_t, std::int64_t
-
-namespace sourcemeta::jsonbinpack {
-
-OutputStream::OutputStream(Stream &output)
-    : sourcemeta::core::BinaryWriter{output} {}
-
-auto OutputStream::put_varint(const std::uint64_t value) -> void {
-  constexpr std::uint8_t LEAST_SIGNIFICANT_BITS{0b01111111};
-  constexpr std::uint8_t MOST_SIGNIFICANT_BIT{0b10000000};
-  constexpr std::uint8_t SHIFT{7};
-  std::uint64_t accumulator = value;
-
-  while (accumulator > LEAST_SIGNIFICANT_BITS) {
-    this->put_byte(static_cast<std::uint8_t>(
-        (accumulator & LEAST_SIGNIFICANT_BITS) | MOST_SIGNIFICANT_BIT));
-    accumulator >>= SHIFT;
-  }
-
-  this->put_byte(static_cast<std::uint8_t>(accumulator));
-}
-
-auto OutputStream::put_varint_zigzag(const std::int64_t value) -> void {
-  this->put_varint(sourcemeta::core::zigzag_encode(value));
-}
-
-auto OutputStream::put_string_utf8(const sourcemeta::core::JSON::String &string,
-                                   const std::uint64_t length) -> void {
-  assert(string.size() == length);
-  // Do a manual for-loop based on the provided length instead of a range
-  // loop based on the string value to avoid accidental overflows
-  for (std::uint64_t index = 0; index < length; index++) {
-    this->put_byte(static_cast<std::uint8_t>(string[index]));
-  }
-}
-
-} // namespace sourcemeta::jsonbinpack
diff --git a/vendor/jsonbinpack/src/runtime/unreachable.h b/vendor/jsonbinpack/src/runtime/unreachable.h
deleted file mode 100644
index 21f95159e..000000000
--- a/vendor/jsonbinpack/src/runtime/unreachable.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_UNREACHABLE_H_
-#define SOURCEMETA_JSONBINPACK_RUNTIME_UNREACHABLE_H_
-
-#include <cassert> // assert
-
-// Until we are on C++23 and can use std::unreachable
-// See https://en.cppreference.com/w/cpp/utility/unreachable
-[[noreturn]] inline void unreachable() {
-  assert(false);
-#if defined(_MSC_VER) && !defined(__clang__)
-  __assume(false);
-#else
-  __builtin_unreachable();
-#endif
-}
-
-#endif