From 9672a115a3e05a2b2069b4b59837e19a8a443f16 Mon Sep 17 00:00:00 2001
From: Juan Cruz Viotti <jv@jviotti.com>
Date: Wed, 18 Sep 2024 08:22:38 +0300
Subject: [PATCH] Upgrade JSON Toolkit to `e86ad1e3`

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>
---
 DEPENDENCIES                                  |   2 +-
 .../sourcemeta/jsontoolkit/json_object.h      |  20 ++-
 .../sourcemeta/jsontoolkit/jsonpointer.h      | 135 +++++++++++++++++-
 .../jsontoolkit/jsonpointer_pointer.h         |  49 +++++++
 .../src/jsonpointer/jsonpointer.cc            |  86 +++++++++--
 vendor/jsontoolkit/src/jsonschema/bundle.cc   |  13 +-
 vendor/jsontoolkit/src/jsonschema/compile.cc  |   9 +-
 .../src/jsonschema/compile_describe.cc        |  49 ++++++-
 .../src/jsonschema/compile_evaluate.cc        |  48 ++++++-
 .../src/jsonschema/compile_helpers.h          |  20 +++
 .../src/jsonschema/compile_json.cc            |   3 +
 .../src/jsonschema/default_compiler_draft4.h  | 101 +++++++++++--
 .../jsontoolkit/jsonschema_bundle.h           |   8 +-
 .../jsontoolkit/jsonschema_compile.h          |  34 +++--
 .../sourcemeta/jsontoolkit/jsonschema_error.h |  14 ++
 15 files changed, 525 insertions(+), 66 deletions(-)

diff --git a/DEPENDENCIES b/DEPENDENCIES
index 0cce3fe7..d6a42a3f 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -1,5 +1,5 @@
 vendorpull https://github.com/sourcemeta/vendorpull dea311b5bfb53b6926a4140267959ae334d3ecf4
 noa https://github.com/sourcemeta/noa 7e26abce7a4e31e86a16ef2851702a56773ca527
-jsontoolkit https://github.com/sourcemeta/jsontoolkit 6c78f131029c647be79cc5da5874fa8d50415cde
+jsontoolkit https://github.com/sourcemeta/jsontoolkit e86ad1e333c11b6fc2659a0f32ae883ef1040e20
 hydra https://github.com/sourcemeta/hydra 3c53d3fdef79e9ba603d48470a508cc45472a0dc
 alterschema https://github.com/sourcemeta/alterschema a31722f04ae2d7e57f2fe5bbb0613670866c0840
diff --git a/vendor/jsontoolkit/src/json/include/sourcemeta/jsontoolkit/json_object.h b/vendor/jsontoolkit/src/json/include/sourcemeta/jsontoolkit/json_object.h
index 1330eeec..b9d2b774 100644
--- a/vendor/jsontoolkit/src/json/include/sourcemeta/jsontoolkit/json_object.h
+++ b/vendor/jsontoolkit/src/json/include/sourcemeta/jsontoolkit/json_object.h
@@ -35,9 +35,27 @@ template <typename Key, typename Value> class JSONObject {
   // Operators
   // We cannot default given that this class references
   // a JSON "value" as an incomplete type
-  auto operator<(const JSONObject<Key, Value> &) const noexcept -> bool {
+
+  auto operator<(const JSONObject<Key, Value> &other) const noexcept -> bool {
+    // The `std::unordered_map` container, by definition, does not provide
+    // ordering. However, we still want some level of ordering to allow
+    // arrays of objects to be sorted.
+
+    // First try a size comparison
+    if (this->data.size() != other.data.size()) {
+      return this->data.size() < other.data.size();
+    }
+
+    // Otherwise do value comparison for common properties
+    for (const auto &[key, value] : this->data) {
+      if (other.data.contains(key) && value < other.data.at(key)) {
+        return true;
+      }
+    }
+
     return false;
   }
+
   auto operator<=(const JSONObject<Key, Value> &other) const noexcept -> bool {
     return this->data <= other.data;
   }
diff --git a/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer.h b/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer.h
index fe789e60..73196bb3 100644
--- a/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer.h
+++ b/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer.h
@@ -37,6 +37,10 @@ using WeakPointer = GenericPointer<std::reference_wrapper<const std::string>>;
 /// A global constant instance of the empty JSON Pointer.
 const Pointer empty_pointer;
 
+/// @ingroup jsonpointer
+/// A global constant instance of the empty JSON WeakPointer.
+const WeakPointer empty_weak_pointer;
+
 /// @ingroup jsonpointer
 /// Get a value from a JSON document using a JSON Pointer (`const` overload).
 ///
@@ -59,6 +63,67 @@ const Pointer empty_pointer;
 SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
 auto get(const JSON &document, const Pointer &pointer) -> const JSON &;
 
+/// @ingroup jsonpointer
+/// Get a value from a JSON document using a JSON WeakPointer (`const`
+/// overload).
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/json.h>
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <cassert>
+/// #include <sstream>
+///
+/// std::istringstream stream{"[ { \"foo\": 1 }, { \"bar\": 2 } ]"};
+/// const sourcemeta::jsontoolkit::JSON document =
+///   sourcemeta::jsontoolkit::parse(stream);
+///
+/// const std::string bar = "bar";
+/// const sourcemeta::jsontoolkit::WeakPointer pointer{1, std::cref(bar)};
+/// const sourcemeta::jsontoolkit::JSON &value{
+///   sourcemeta::jsontoolkit::get(document, pointer)};
+/// assert(value.is_integer());
+/// assert(value.to_integer() == 2);
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto get(const JSON &document, const WeakPointer &pointer) -> const JSON &;
+
+/// @ingroup jsonpointer
+/// Check that a path represented by a JSON Pointer exists in the given
+/// document. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/json.h>
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <cassert>
+/// #include <sstream>
+///
+/// std::istringstream stream{"[ { \"foo\": 1 }, { \"bar\": 2 } ]"};
+/// const auto document{sourcemeta::jsontoolkit::parse(stream)};
+/// const sourcemeta::jsontoolkit::Pointer pointer{1, "bar"};
+/// assert(sourcemeta::jsontoolkit::has(document, pointer));
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto has(const JSON &document, const Pointer &pointer) -> bool;
+
+/// @ingroup jsonpointer
+/// Check that a path represented by a JSON WeakPointer exists in the given
+/// document. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/json.h>
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <cassert>
+/// #include <sstream>
+///
+/// std::istringstream stream{"[ { \"foo\": 1 }, { \"bar\": 2 } ]"};
+/// const auto document{sourcemeta::jsontoolkit::parse(stream)};
+/// const std::string bar = "bar";
+/// const sourcemeta::jsontoolkit::WeakPointer pointer{1, std::cref(bar)};
+/// assert(sourcemeta::jsontoolkit::has(document, pointer));
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto has(const JSON &document, const WeakPointer &pointer) -> bool;
+
 /// @ingroup jsonpointer
 /// Get a value from a JSON document using a JSON Pointer (non-`const`
 /// overload).
@@ -98,13 +163,38 @@ auto get(JSON &document, const Pointer &pointer) -> JSON &;
 ///   sourcemeta::jsontoolkit::parse(stream);
 ///
 /// const sourcemeta::jsontoolkit::JSON &value{
-///   sourcemeta::jsontoolkit::get(document, "bar")};
+///   sourcemeta::jsontoolkit::get(document,
+///   sourcemeta::jsontoolkit::Pointer{"foo"})};
 /// assert(value.is_integer());
-/// assert(value.to_integer() == 2);
+/// assert(value.to_integer() == 1);
 /// ```
 SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
 auto get(const JSON &document, const Pointer::Token &token) -> const JSON &;
 
+/// @ingroup jsonpointer
+/// Get a value from a JSON document using a JSON WeakPointer token (`const`
+/// overload).
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/json.h>
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <cassert>
+/// #include <sstream>
+///
+/// std::istringstream stream{"{ \"foo\": 1 }"};
+/// const sourcemeta::jsontoolkit::JSON document =
+///   sourcemeta::jsontoolkit::parse(stream);
+///
+/// const std::string foo = "foo";
+/// const sourcemeta::jsontoolkit::JSON &value{
+///   sourcemeta::jsontoolkit::get(document,
+///   sourcemeta::jsontoolkit::WeakPointer{std::cref(foo)})};
+/// assert(value.is_integer());
+/// assert(value.to_integer() == 1);
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto get(const JSON &document, const WeakPointer::Token &token) -> const JSON &;
+
 /// @ingroup jsonpointer
 /// Get a value from a JSON document using a JSON Pointer token (non-`const`
 /// overload).
@@ -233,6 +323,27 @@ auto stringify(const Pointer &pointer,
                std::basic_ostream<JSON::Char, JSON::CharTraits> &stream)
     -> void;
 
+/// @ingroup jsonpointer
+///
+/// Stringify the input JSON WeakPointer into a given C++ standard output
+/// stream. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <iostream>
+/// #include <sstream>
+///
+/// const std::string foo = "foo";
+/// const sourcemeta::jsontoolkit::WeakPointer pointer{std::cref(foo)};
+/// std::ostringstream stream;
+/// sourcemeta::jsontoolkit::stringify(pointer, stream);
+/// std::cout << stream.str() << std::endl;
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto stringify(const WeakPointer &pointer,
+               std::basic_ostream<JSON::Char, JSON::CharTraits> &stream)
+    -> void;
+
 /// @ingroup jsonpointer
 ///
 /// Stringify the input JSON Pointer into a C++ standard string. For example:
@@ -251,6 +362,26 @@ auto to_string(const Pointer &pointer)
     -> std::basic_string<JSON::Char, JSON::CharTraits,
                          std::allocator<JSON::Char>>;
 
+/// @ingroup jsonpointer
+///
+/// Stringify the input JSON WeakPointer into a C++ standard string. For
+/// example:
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+/// #include <string>
+/// #include <iostream>
+///
+/// const std::string foo = "foo";
+/// const sourcemeta::jsontoolkit::WeakPointer pointer{foo};
+/// const std::string result{sourcemeta::jsontoolkit::to_string(pointer)};
+/// std::cout << result << std::endl;
+/// ```
+SOURCEMETA_JSONTOOLKIT_JSONPOINTER_EXPORT
+auto to_string(const WeakPointer &pointer)
+    -> std::basic_string<JSON::Char, JSON::CharTraits,
+                         std::allocator<JSON::Char>>;
+
 /// @ingroup jsonpointer
 ///
 /// Stringify the input JSON Pointer into a properly escaped URI fragment. For
diff --git a/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer_pointer.h b/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer_pointer.h
index 44c1ab0a..801021d4 100644
--- a/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer_pointer.h
+++ b/vendor/jsontoolkit/src/jsonpointer/include/sourcemeta/jsontoolkit/jsonpointer_pointer.h
@@ -5,10 +5,12 @@
 
 #include <algorithm>        // std::copy, std::equal
 #include <cassert>          // assert
+#include <functional>       // std::reference_wrapper
 #include <initializer_list> // std::initializer_list
 #include <iterator>         // std::advance, std::back_inserter
 #include <sstream>          // std::basic_ostringstream
 #include <stdexcept>        // std::runtime_error
+#include <type_traits>      // std::enable_if_t, std::is_same_v
 #include <utility>          // std::move
 #include <vector>           // std::vector
 
@@ -238,6 +240,53 @@ template <typename PropertyT> class GenericPointer {
               std::back_inserter(this->data));
   }
 
+  /// Push a JSON Pointer into the back of a JSON WeakPointer. Make sure that
+  /// the pointer you are pushing remains alive for the duration of the
+  /// WeakPointer. For example:
+  ///
+  /// ```cpp
+  /// #include <sourcemeta/jsontoolkit/jsonpointer.h>
+  /// #include <cassert>
+  ///
+  /// const std::string foo{"foo"};
+  /// sourcemeta::jsontoolkit::WeakPointer pointer{std::cref(foo)};
+  /// const sourcemeta::jsontoolkit::Pointer other{"bar", "baz"};
+  /// pointer.push_back(other);
+  /// assert(pointer.size() == 3);
+  ///
+  /// assert(pointer.at(0).is_property());
+  /// assert(pointer.at(1).is_property());
+  /// assert(pointer.at(2).is_property());
+  ///
+  /// assert(pointer.at(0).to_property() == "foo");
+  /// assert(pointer.at(1).to_property() == "bar");
+  /// assert(pointer.at(2).to_property() == "baz");
+  /// ```
+  template <typename OtherT,
+            typename = std::enable_if_t<std::is_same_v<
+                PropertyT, std::reference_wrapper<const OtherT>>>>
+  auto push_back(const GenericPointer<OtherT> &other) -> void {
+    if (other.empty()) {
+      return;
+    } else if (other.size() == 1) {
+      const auto &token{other.back()};
+      if (token.is_property()) {
+        this->data.emplace_back(token.to_property());
+      } else {
+        this->data.emplace_back(token.to_index());
+      }
+    } else {
+      this->data.reserve(this->data.size() + other.size());
+      for (const auto &token : other) {
+        if (token.is_property()) {
+          this->data.emplace_back(token.to_property());
+        } else {
+          this->data.emplace_back(token.to_index());
+        }
+      }
+    }
+  }
+
   /// Push a property token into the back of a JSON Pointer.
   /// For example:
   ///
diff --git a/vendor/jsontoolkit/src/jsonpointer/jsonpointer.cc b/vendor/jsontoolkit/src/jsonpointer/jsonpointer.cc
index 9c98c07e..9664ea0d 100644
--- a/vendor/jsontoolkit/src/jsonpointer/jsonpointer.cc
+++ b/vendor/jsontoolkit/src/jsonpointer/jsonpointer.cc
@@ -13,16 +13,14 @@
 #include <utility>     // std::move
 
 namespace {
-template <template <typename T> typename Allocator, typename V>
-auto traverse(V &document,
-              typename sourcemeta::jsontoolkit::GenericPointer<
-                  typename V::String>::const_iterator begin,
-              typename sourcemeta::jsontoolkit::GenericPointer<
-                  typename V::String>::const_iterator end) -> V & {
-  using Pointer = sourcemeta::jsontoolkit::GenericPointer<typename V::String>;
+template <template <typename T> typename Allocator, typename V,
+          typename PointerT =
+              sourcemeta::jsontoolkit::GenericPointer<typename V::String>>
+auto traverse(V &document, typename PointerT::const_iterator begin,
+              typename PointerT::const_iterator end) -> V & {
   // Make sure types match
   static_assert(
-      std::is_same_v<typename Pointer::Value, std::remove_const_t<V>>);
+      std::is_same_v<typename PointerT::Value, std::remove_const_t<V>>);
 
   std::reference_wrapper<V> current{document};
 
@@ -56,6 +54,39 @@ auto traverse(V &document,
   return current.get();
 }
 
+template <typename PointerT>
+auto check(const sourcemeta::jsontoolkit::JSON &document,
+           typename PointerT::const_iterator begin,
+           typename PointerT::const_iterator end) -> bool {
+  std::reference_wrapper<const sourcemeta::jsontoolkit::JSON> current{document};
+  for (auto iterator = begin; iterator != end; ++iterator) {
+    const auto &token{*iterator};
+    const auto &instance{current.get()};
+    const bool is_last{std::next(iterator) == end};
+    if (token.is_property()) {
+      const auto &property{token.to_property()};
+      if (is_last) {
+        return instance.defines(property);
+      } else if (instance.defines(property)) {
+        current = instance.at(property);
+      } else {
+        return false;
+      }
+    } else {
+      const auto index{token.to_index()};
+      if (is_last) {
+        return index < instance.size();
+      } else if (index < instance.size()) {
+        current = instance.at(index);
+      } else {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
 } // namespace
 
 namespace sourcemeta::jsontoolkit {
@@ -65,11 +96,24 @@ auto get(const JSON &document, const Pointer &pointer) -> const JSON & {
                                               std::cend(pointer));
 }
 
+auto get(const JSON &document, const WeakPointer &pointer) -> const JSON & {
+  return traverse<std::allocator, const JSON, WeakPointer>(
+      document, std::cbegin(pointer), std::cend(pointer));
+}
+
 auto get(JSON &document, const Pointer &pointer) -> JSON & {
   return traverse<std::allocator, JSON>(document, std::cbegin(pointer),
                                         std::cend(pointer));
 }
 
+auto has(const JSON &document, const Pointer &pointer) -> bool {
+  return check<Pointer>(document, std::cbegin(pointer), std::cend(pointer));
+}
+
+auto has(const JSON &document, const WeakPointer &pointer) -> bool {
+  return check<WeakPointer>(document, std::cbegin(pointer), std::cend(pointer));
+}
+
 auto get(const JSON &document, const Pointer::Token &token) -> const JSON & {
   if (token.is_property()) {
     return document.at(token.to_property());
@@ -78,6 +122,15 @@ auto get(const JSON &document, const Pointer::Token &token) -> const JSON & {
   }
 }
 
+auto get(const JSON &document,
+         const WeakPointer::Token &token) -> const JSON & {
+  if (token.is_property()) {
+    return document.at(token.to_property());
+  } else {
+    return document.at(token.to_index());
+  }
+}
+
 auto get(JSON &document, const Pointer::Token &token) -> JSON & {
   if (token.is_property()) {
     return document.at(token.to_property());
@@ -157,6 +210,13 @@ auto stringify(const Pointer &pointer,
                                                           false);
 }
 
+auto stringify(const WeakPointer &pointer,
+               std::basic_ostream<JSON::Char, JSON::CharTraits> &stream)
+    -> void {
+  stringify<JSON::Char, JSON::CharTraits, std::allocator>(pointer, stream,
+                                                          false);
+}
+
 auto to_string(const Pointer &pointer)
     -> std::basic_string<JSON::Char, JSON::CharTraits,
                          std::allocator<JSON::Char>> {
@@ -167,6 +227,16 @@ auto to_string(const Pointer &pointer)
   return result.str();
 }
 
+auto to_string(const WeakPointer &pointer)
+    -> std::basic_string<JSON::Char, JSON::CharTraits,
+                         std::allocator<JSON::Char>> {
+  std::basic_ostringstream<JSON::Char, JSON::CharTraits,
+                           std::allocator<JSON::Char>>
+      result;
+  stringify(pointer, result);
+  return result.str();
+}
+
 auto to_uri(const Pointer &pointer) -> URI {
   std::basic_ostringstream<JSON::Char, JSON::CharTraits,
                            std::allocator<JSON::Char>>
diff --git a/vendor/jsontoolkit/src/jsonschema/bundle.cc b/vendor/jsontoolkit/src/jsonschema/bundle.cc
index 91b1a8b5..cd4ae5b0 100644
--- a/vendor/jsontoolkit/src/jsonschema/bundle.cc
+++ b/vendor/jsontoolkit/src/jsonschema/bundle.cc
@@ -197,8 +197,7 @@ namespace sourcemeta::jsontoolkit {
 
 auto bundle(sourcemeta::jsontoolkit::JSON &schema, const SchemaWalker &walker,
             const SchemaResolver &resolver, const BundleOptions options,
-            const std::optional<std::string> &default_dialect)
-    -> std::future<void> {
+            const std::optional<std::string> &default_dialect) -> void {
   const auto vocabularies{
       sourcemeta::jsontoolkit::vocabularies(schema, resolver, default_dialect)
           .get()};
@@ -209,20 +208,16 @@ auto bundle(sourcemeta::jsontoolkit::JSON &schema, const SchemaWalker &walker,
   if (options == BundleOptions::WithoutIdentifiers) {
     remove_identifiers(schema, walker, resolver, default_dialect);
   }
-
-  return std::promise<void>{}.get_future();
 }
 
 auto bundle(const sourcemeta::jsontoolkit::JSON &schema,
             const SchemaWalker &walker, const SchemaResolver &resolver,
             const BundleOptions options,
             const std::optional<std::string> &default_dialect)
-    -> std::future<sourcemeta::jsontoolkit::JSON> {
+    -> sourcemeta::jsontoolkit::JSON {
   sourcemeta::jsontoolkit::JSON copy = schema;
-  bundle(copy, walker, resolver, options, default_dialect).wait();
-  std::promise<sourcemeta::jsontoolkit::JSON> promise;
-  promise.set_value(std::move(copy));
-  return promise.get_future();
+  bundle(copy, walker, resolver, options, default_dialect);
+  return copy;
 }
 
 } // namespace sourcemeta::jsontoolkit
diff --git a/vendor/jsontoolkit/src/jsonschema/compile.cc b/vendor/jsontoolkit/src/jsonschema/compile.cc
index 7ff99a65..7bb2c58e 100644
--- a/vendor/jsontoolkit/src/jsonschema/compile.cc
+++ b/vendor/jsontoolkit/src/jsonschema/compile.cc
@@ -70,9 +70,8 @@ auto compile(const JSON &schema, const SchemaWalker &walker,
 
   // Make sure the input schema is bundled, otherwise we won't be able to
   // resolve remote references here
-  const JSON result{
-      bundle(schema, walker, resolver, BundleOptions::Default, default_dialect)
-          .get()};
+  const JSON result{bundle(schema, walker, resolver, BundleOptions::Default,
+                           default_dialect)};
 
   // Perform framing to resolve references later on
   ReferenceFrame frame;
@@ -215,7 +214,7 @@ auto compile(const SchemaCompilerContext &context,
 }
 
 SchemaCompilerErrorTraceOutput::SchemaCompilerErrorTraceOutput(
-    const JSON &instance, const Pointer &base)
+    const JSON &instance, const WeakPointer &base)
     : instance_{instance}, base_{base} {}
 
 auto SchemaCompilerErrorTraceOutput::begin() const -> const_iterator {
@@ -237,7 +236,7 @@ auto SchemaCompilerErrorTraceOutput::cend() const -> const_iterator {
 auto SchemaCompilerErrorTraceOutput::operator()(
     const SchemaCompilerEvaluationType type, const bool result,
     const SchemaCompilerTemplate::value_type &step,
-    const Pointer &evaluate_path, const Pointer &instance_location,
+    const WeakPointer &evaluate_path, const WeakPointer &instance_location,
     const JSON &annotation) -> void {
   assert(!evaluate_path.empty());
   assert(evaluate_path.back().is_property());
diff --git a/vendor/jsontoolkit/src/jsonschema/compile_describe.cc b/vendor/jsontoolkit/src/jsonschema/compile_describe.cc
index ff710593..32633599 100644
--- a/vendor/jsontoolkit/src/jsonschema/compile_describe.cc
+++ b/vendor/jsontoolkit/src/jsonschema/compile_describe.cc
@@ -105,7 +105,7 @@ auto describe_reference(const JSON &target) -> std::string {
   return message.str();
 }
 
-auto is_within_keyword(const Pointer &evaluate_path,
+auto is_within_keyword(const WeakPointer &evaluate_path,
                        const std::string &keyword) -> bool {
   return std::any_of(evaluate_path.cbegin(), evaluate_path.cend(),
                      [&keyword](const auto &token) {
@@ -122,9 +122,9 @@ auto unknown() -> std::string {
 
 struct DescribeVisitor {
   const bool valid;
-  const Pointer &evaluate_path;
+  const WeakPointer &evaluate_path;
   const std::string &keyword;
-  const Pointer &instance_location;
+  const WeakPointer &instance_location;
   const JSON &target;
   const JSON &annotation;
 
@@ -1267,6 +1267,44 @@ struct DescribeVisitor {
     return message.str();
   }
 
+  auto operator()(const SchemaCompilerAssertionPropertyType &step) const
+      -> std::string {
+    std::ostringstream message;
+    const auto &value{step_value(step)};
+    if (!this->valid && value == JSON::Type::Real &&
+        this->target.type() == JSON::Type::Integer) {
+      message
+          << "The value was expected to be a real number but it was an integer";
+    } else if (!this->valid && value == JSON::Type::Integer &&
+               this->target.type() == JSON::Type::Real) {
+      message
+          << "The value was expected to be an integer but it was a real number";
+    } else {
+      describe_type_check(this->valid, this->target.type(), value, message);
+    }
+
+    return message.str();
+  }
+
+  auto operator()(const SchemaCompilerAssertionPropertyTypeStrict &step) const
+      -> std::string {
+    std::ostringstream message;
+    const auto &value{step_value(step)};
+    if (!this->valid && value == JSON::Type::Real &&
+        this->target.type() == JSON::Type::Integer) {
+      message
+          << "The value was expected to be a real number but it was an integer";
+    } else if (!this->valid && value == JSON::Type::Integer &&
+               this->target.type() == JSON::Type::Real) {
+      message
+          << "The value was expected to be an integer but it was a real number";
+    } else {
+      describe_type_check(this->valid, this->target.type(), value, message);
+    }
+
+    return message.str();
+  }
+
   auto operator()(const SchemaCompilerLoopPropertiesMatch &step) const
       -> std::string {
     assert(!step.children.empty());
@@ -1656,8 +1694,9 @@ namespace sourcemeta::jsontoolkit {
 // TODO: What will unlock even better error messages is being able to
 // get the subschema being evaluated along with the keyword
 auto describe(const bool valid, const SchemaCompilerTemplate::value_type &step,
-              const Pointer &evaluate_path, const Pointer &instance_location,
-              const JSON &instance, const JSON &annotation) -> std::string {
+              const WeakPointer &evaluate_path,
+              const WeakPointer &instance_location, const JSON &instance,
+              const JSON &annotation) -> std::string {
   assert(evaluate_path.empty() || evaluate_path.back().is_property());
   return std::visit<std::string>(
       DescribeVisitor{
diff --git a/vendor/jsontoolkit/src/jsonschema/compile_evaluate.cc b/vendor/jsontoolkit/src/jsonschema/compile_evaluate.cc
index 516abaf8..9f539c50 100644
--- a/vendor/jsontoolkit/src/jsonschema/compile_evaluate.cc
+++ b/vendor/jsontoolkit/src/jsonschema/compile_evaluate.cc
@@ -19,7 +19,7 @@ namespace {
 
 class EvaluationContext {
 public:
-  using Pointer = sourcemeta::jsontoolkit::Pointer;
+  using Pointer = sourcemeta::jsontoolkit::WeakPointer;
   using JSON = sourcemeta::jsontoolkit::JSON;
   using Template = sourcemeta::jsontoolkit::SchemaCompilerTemplate;
   EvaluationContext(const JSON &instance) : instances_{instance} {};
@@ -166,16 +166,23 @@ class EvaluationContext {
   }
 
   template <typename T> auto push(const T &step) -> void {
-    assert(step.relative_instance_location.size() <= 1);
+    // Guard against infinite recursion in a cheap manner, as
+    // infinite recursion will manifest itself through huge
+    // ever-growing evaluate paths
+    constexpr auto EVALUATE_PATH_LIMIT{400};
+    if (this->evaluate_path_.size() > EVALUATE_PATH_LIMIT) [[unlikely]] {
+      throw sourcemeta::jsontoolkit::SchemaEvaluationError(
+          "The evaluation path depth limit was reached "
+          "likely due to infinite recursion");
+    }
+
     this->frame_sizes.emplace_back(step.relative_schema_location.size(),
                                    step.relative_instance_location.size());
     this->evaluate_path_.push_back(step.relative_schema_location);
     this->instance_location_.push_back(step.relative_instance_location);
-    assert(step.relative_instance_location.size() <= 1);
     if (!step.relative_instance_location.empty()) {
       this->instances_.emplace_back(
-          get(this->instances_.back().get(),
-              step.relative_instance_location.back()));
+          get(this->instances_.back().get(), step.relative_instance_location));
     }
 
     if (step.dynamic) {
@@ -192,8 +199,7 @@ class EvaluationContext {
     const auto &sizes{this->frame_sizes.back()};
     this->evaluate_path_.pop_back(sizes.first);
     this->instance_location_.pop_back(sizes.second);
-    assert(sizes.second <= 1);
-    if (sizes.second == 1) {
+    if (sizes.second > 0) {
       this->instances_.pop_back();
     }
 
@@ -598,6 +604,34 @@ auto evaluate_step(
     }
 
     EVALUATE_END(assertion, SchemaCompilerAssertionStringType);
+  } else if (IS_STEP(SchemaCompilerAssertionPropertyType)) {
+    EVALUATE_BEGIN_NO_TARGET(assertion, SchemaCompilerAssertionPropertyType,
+                             // Note that here are are referring to the parent
+                             // object that might hold the given property,
+                             // before traversing into the actual property
+                             context.resolve_target().is_object() &&
+                                 has(context.resolve_target(),
+                                     assertion.relative_instance_location));
+    // Now here we refer to the actual property
+    const auto &target{context.resolve_target()};
+    // In non-strict mode, we consider a real number that represents an
+    // integer to be an integer
+    result =
+        target.type() == assertion.value ||
+        (assertion.value == JSON::Type::Integer && target.is_integer_real());
+    EVALUATE_END(assertion, SchemaCompilerAssertionPropertyType);
+  } else if (IS_STEP(SchemaCompilerAssertionPropertyTypeStrict)) {
+    EVALUATE_BEGIN_NO_TARGET(assertion,
+                             SchemaCompilerAssertionPropertyTypeStrict,
+                             // Note that here are are referring to the parent
+                             // object that might hold the given property,
+                             // before traversing into the actual property
+                             context.resolve_target().is_object() &&
+                                 has(context.resolve_target(),
+                                     assertion.relative_instance_location));
+    // Now here we refer to the actual property
+    result = context.resolve_target().type() == assertion.value;
+    EVALUATE_END(assertion, SchemaCompilerAssertionPropertyTypeStrict);
   } else if (IS_STEP(SchemaCompilerLogicalOr)) {
     EVALUATE_BEGIN_NO_PRECONDITION(logical, SchemaCompilerLogicalOr);
     result = logical.children.empty();
diff --git a/vendor/jsontoolkit/src/jsonschema/compile_helpers.h b/vendor/jsontoolkit/src/jsonschema/compile_helpers.h
index 23d73feb..89e15b90 100644
--- a/vendor/jsontoolkit/src/jsonschema/compile_helpers.h
+++ b/vendor/jsontoolkit/src/jsonschema/compile_helpers.h
@@ -3,6 +3,7 @@
 
 #include <sourcemeta/jsontoolkit/jsonschema_compile.h>
 
+#include <cassert> // assert
 #include <utility> // std::declval, std::move
 
 namespace sourcemeta::jsontoolkit {
@@ -52,6 +53,25 @@ auto make(const bool report, const SchemaCompilerContext &context,
       std::move(children)};
 }
 
+template <typename Type, typename Step>
+auto unroll(const SchemaCompilerDynamicContext &dynamic_context,
+            const Step &step,
+            const Pointer &base_instance_location = empty_pointer) -> Type {
+  assert(std::holds_alternative<Type>(step));
+  return {dynamic_context.keyword.empty()
+              ? std::get<Type>(step).relative_schema_location
+              : dynamic_context.base_schema_location
+                    .concat({dynamic_context.keyword})
+                    .concat(std::get<Type>(step).relative_schema_location),
+          base_instance_location.concat(
+              std::get<Type>(step).relative_instance_location),
+          std::get<Type>(step).keyword_location,
+          std::get<Type>(step).schema_resource,
+          std::get<Type>(step).dynamic,
+          std::get<Type>(step).report,
+          std::get<Type>(step).value};
+}
+
 } // namespace sourcemeta::jsontoolkit
 
 #endif
diff --git a/vendor/jsontoolkit/src/jsonschema/compile_json.cc b/vendor/jsontoolkit/src/jsonschema/compile_json.cc
index e873d28a..6903eab5 100644
--- a/vendor/jsontoolkit/src/jsonschema/compile_json.cc
+++ b/vendor/jsontoolkit/src/jsonschema/compile_json.cc
@@ -238,6 +238,9 @@ struct StepVisitor {
   HANDLE_STEP("assertion", "unique", SchemaCompilerAssertionUnique)
   HANDLE_STEP("assertion", "divisible", SchemaCompilerAssertionDivisible)
   HANDLE_STEP("assertion", "string-type", SchemaCompilerAssertionStringType)
+  HANDLE_STEP("assertion", "property-type", SchemaCompilerAssertionPropertyType)
+  HANDLE_STEP("assertion", "property-type-strict",
+              SchemaCompilerAssertionPropertyTypeStrict)
   HANDLE_STEP("assertion", "equals-any", SchemaCompilerAssertionEqualsAny)
   HANDLE_STEP("annotation", "emit", SchemaCompilerAnnotationEmit)
   HANDLE_STEP("annotation", "when-array-size-equal",
diff --git a/vendor/jsontoolkit/src/jsonschema/default_compiler_draft4.h b/vendor/jsontoolkit/src/jsonschema/default_compiler_draft4.h
index 1d324d53..b3af97ec 100644
--- a/vendor/jsontoolkit/src/jsonschema/default_compiler_draft4.h
+++ b/vendor/jsontoolkit/src/jsonschema/default_compiler_draft4.h
@@ -56,11 +56,22 @@ auto compiler_draft4_core_ref(const SchemaCompilerContext &context,
            context.frame.at({type, reference.destination}).pointer)) ||
       schema_context.references.contains(reference.destination)};
   if (!is_recursive) {
-    return {make<SchemaCompilerLogicalAnd>(
-        true, context, schema_context, dynamic_context,
-        SchemaCompilerValueNone{},
-        compile(context, new_schema_context, relative_dynamic_context,
-                empty_pointer, empty_pointer, reference.destination))};
+    // TODO: Enable this optimization for 2019-09 on-wards
+    if (schema_context.vocabularies.contains(
+            "http://json-schema.org/draft-04/schema#") ||
+        schema_context.vocabularies.contains(
+            "http://json-schema.org/draft-06/schema#") ||
+        schema_context.vocabularies.contains(
+            "http://json-schema.org/draft-07/schema#")) {
+      return compile(context, new_schema_context, dynamic_context,
+                     empty_pointer, empty_pointer, reference.destination);
+    } else {
+      return {make<SchemaCompilerLogicalAnd>(
+          true, context, schema_context, dynamic_context,
+          SchemaCompilerValueNone{},
+          compile(context, new_schema_context, relative_dynamic_context,
+                  empty_pointer, empty_pointer, reference.destination))};
+    }
   }
 
   // The idea to handle recursion is to expand the reference once, and when
@@ -360,8 +371,14 @@ auto compiler_draft4_applicator_properties_conditional_annotation(
   // or whether most of the properties are optional. Each shines
   // in the corresponding case.
 
-  // This strategy only makes sense if most of the properties are "optional"
-  if (is_required <= (size / 2)) {
+  const auto prefer_loop_over_instance{
+      // This strategy only makes sense if most of the properties are "optional"
+      is_required <= (size / 2) &&
+      // If `properties` only defines a relatively small amount of properties,
+      // then its probably still faster to unroll
+      schema_context.schema.at(dynamic_context.keyword).size() > 3};
+
+  if (prefer_loop_over_instance) {
     SchemaCompilerValueNamedIndexes indexes;
     SchemaCompilerTemplate children;
     std::size_t cursor = 0;
@@ -408,6 +425,46 @@ auto compiler_draft4_applicator_properties_conditional_annotation(
       for (auto &&substep : substeps) {
         children.push_back(std::move(substep));
       }
+
+      // Optimize `properties` where its subschemas just include a type check,
+      // as that's a very common pattern
+
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<SchemaCompilerAssertionTypeStrict>(
+                   substeps.front())) {
+      const auto &type_step{
+          std::get<SchemaCompilerAssertionTypeStrict>(substeps.front())};
+      children.push_back(SchemaCompilerAssertionPropertyTypeStrict{
+          type_step.relative_schema_location,
+          dynamic_context.base_instance_location.concat(
+              type_step.relative_instance_location),
+          type_step.keyword_location, type_step.schema_resource,
+          type_step.dynamic, type_step.report, type_step.value});
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<SchemaCompilerAssertionType>(
+                   substeps.front())) {
+      const auto &type_step{
+          std::get<SchemaCompilerAssertionType>(substeps.front())};
+      children.push_back(SchemaCompilerAssertionPropertyType{
+          type_step.relative_schema_location,
+          dynamic_context.base_instance_location.concat(
+              type_step.relative_instance_location),
+          type_step.keyword_location, type_step.schema_resource,
+          type_step.dynamic, type_step.report, type_step.value});
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<
+                   SchemaCompilerAssertionPropertyTypeStrict>(
+                   substeps.front())) {
+      children.push_back(unroll<SchemaCompilerAssertionPropertyTypeStrict>(
+          relative_dynamic_context, substeps.front(),
+          dynamic_context.base_instance_location));
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<SchemaCompilerAssertionPropertyType>(
+                   substeps.front())) {
+      children.push_back(unroll<SchemaCompilerAssertionPropertyType>(
+          relative_dynamic_context, substeps.front(),
+          dynamic_context.base_instance_location));
+
     } else {
       children.push_back(make<SchemaCompilerLogicalWhenDefines>(
           false, context, schema_context, relative_dynamic_context,
@@ -415,6 +472,14 @@ auto compiler_draft4_applicator_properties_conditional_annotation(
     }
   }
 
+  // Optimize away the wrapper when emitting a single instruction
+  if (children.size() == 1 &&
+      std::holds_alternative<SchemaCompilerAssertionPropertyTypeStrict>(
+          children.front())) {
+    return {unroll<SchemaCompilerAssertionPropertyTypeStrict>(
+        dynamic_context, children.front())};
+  }
+
   return {make<SchemaCompilerLogicalAnd>(
       true, context, schema_context, dynamic_context, SchemaCompilerValueNone{},
       std::move(children))};
@@ -470,13 +535,21 @@ auto compiler_draft4_applicator_patternproperties_conditional_annotation(
           SchemaCompilerValueNone{}));
     }
 
-    // Loop over the instance properties
-    children.push_back(make<SchemaCompilerLoopPropertiesRegex>(
-        // Treat this as an internal step
-        false, context, schema_context, relative_dynamic_context,
-        SchemaCompilerValueRegex{std::regex{pattern, std::regex::ECMAScript},
-                                 pattern},
-        std::move(substeps)));
+    // If the `patternProperties` subschema for the given pattern does
+    // nothing, then we can avoid generating an entire loop for it
+    if (!substeps.empty()) {
+      // Loop over the instance properties
+      children.push_back(make<SchemaCompilerLoopPropertiesRegex>(
+          // Treat this as an internal step
+          false, context, schema_context, relative_dynamic_context,
+          SchemaCompilerValueRegex{std::regex{pattern, std::regex::ECMAScript},
+                                   pattern},
+          std::move(substeps)));
+    }
+  }
+
+  if (children.empty()) {
+    return {};
   }
 
   // If the instance is an object...
diff --git a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_bundle.h b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_bundle.h
index 86c99ecd..1a815191 100644
--- a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_bundle.h
+++ b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_bundle.h
@@ -65,7 +65,7 @@ enum class BundleOptions {
 /// })JSON");
 ///
 /// sourcemeta::jsontoolkit::bundle(document,
-///   sourcemeta::jsontoolkit::default_schema_walker, test_resolver).wait();
+///   sourcemeta::jsontoolkit::default_schema_walker, test_resolver);
 ///
 /// const sourcemeta::jsontoolkit::JSON expected =
 ///     sourcemeta::jsontoolkit::parse(R"JSON({
@@ -87,7 +87,7 @@ auto bundle(sourcemeta::jsontoolkit::JSON &schema, const SchemaWalker &walker,
             const SchemaResolver &resolver,
             const BundleOptions options = BundleOptions::Default,
             const std::optional<std::string> &default_dialect = std::nullopt)
-    -> std::future<void>;
+    -> void;
 
 /// @ingroup jsonschema
 ///
@@ -127,7 +127,7 @@ auto bundle(sourcemeta::jsontoolkit::JSON &schema, const SchemaWalker &walker,
 ///
 /// const sourcemeta::jsontoolkit::JSON result =
 ///   sourcemeta::jsontoolkit::bundle(document,
-///     sourcemeta::jsontoolkit::default_schema_walker, test_resolver).get();
+///     sourcemeta::jsontoolkit::default_schema_walker, test_resolver);
 ///
 /// const sourcemeta::jsontoolkit::JSON expected =
 ///     sourcemeta::jsontoolkit::parse(R"JSON({
@@ -149,7 +149,7 @@ auto bundle(const sourcemeta::jsontoolkit::JSON &schema,
             const SchemaWalker &walker, const SchemaResolver &resolver,
             const BundleOptions options = BundleOptions::Default,
             const std::optional<std::string> &default_dialect = std::nullopt)
-    -> std::future<sourcemeta::jsontoolkit::JSON>;
+    -> sourcemeta::jsontoolkit::JSON;
 
 } // namespace sourcemeta::jsontoolkit
 
diff --git a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h
index 7f997e5e..1b7b6199 100644
--- a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h
+++ b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h
@@ -147,6 +147,8 @@ struct SchemaCompilerAssertionLess;
 struct SchemaCompilerAssertionUnique;
 struct SchemaCompilerAssertionDivisible;
 struct SchemaCompilerAssertionStringType;
+struct SchemaCompilerAssertionPropertyType;
+struct SchemaCompilerAssertionPropertyTypeStrict;
 struct SchemaCompilerAnnotationEmit;
 struct SchemaCompilerAnnotationWhenArraySizeEqual;
 struct SchemaCompilerAnnotationWhenArraySizeGreater;
@@ -197,7 +199,9 @@ using SchemaCompilerTemplate = std::vector<std::variant<
     SchemaCompilerAssertionLessEqual, SchemaCompilerAssertionGreater,
     SchemaCompilerAssertionLess, SchemaCompilerAssertionUnique,
     SchemaCompilerAssertionDivisible, SchemaCompilerAssertionStringType,
-    SchemaCompilerAnnotationEmit, SchemaCompilerAnnotationWhenArraySizeEqual,
+    SchemaCompilerAssertionPropertyType,
+    SchemaCompilerAssertionPropertyTypeStrict, SchemaCompilerAnnotationEmit,
+    SchemaCompilerAnnotationWhenArraySizeEqual,
     SchemaCompilerAnnotationWhenArraySizeGreater,
     SchemaCompilerAnnotationToParent, SchemaCompilerAnnotationBasenameToParent,
     SchemaCompilerLogicalOr, SchemaCompilerLogicalAnd, SchemaCompilerLogicalXor,
@@ -372,6 +376,16 @@ DEFINE_STEP_WITH_VALUE(Assertion, Divisible, SchemaCompilerValueJSON)
 /// a certain type
 DEFINE_STEP_WITH_VALUE(Assertion, StringType, SchemaCompilerValueStringType)
 
+/// @ingroup jsonschema_compiler_instructions
+/// @brief Represents a compiler assertion step that checks that an instance
+/// property is of a given type if present
+DEFINE_STEP_WITH_VALUE(Assertion, PropertyType, SchemaCompilerValueType)
+
+/// @ingroup jsonschema_compiler_instructions
+/// @brief Represents a compiler assertion step that checks that an instance
+/// property is of a given type if present (strict mode)
+DEFINE_STEP_WITH_VALUE(Assertion, PropertyTypeStrict, SchemaCompilerValueType)
+
 /// @ingroup jsonschema_compiler_instructions
 /// @brief Represents a compiler step that emits an annotation
 DEFINE_STEP_WITH_VALUE(Annotation, Emit, SchemaCompilerValueJSON)
@@ -613,7 +627,7 @@ enum class SchemaCompilerEvaluationType { Pre, Post };
 using SchemaCompilerEvaluationCallback =
     std::function<void(const SchemaCompilerEvaluationType, bool,
                        const SchemaCompilerTemplate::value_type &,
-                       const Pointer &, const Pointer &, const JSON &)>;
+                       const WeakPointer &, const WeakPointer &, const JSON &)>;
 
 // TODO: Support standard output formats too
 
@@ -660,7 +674,7 @@ using SchemaCompilerEvaluationCallback =
 class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaCompilerErrorTraceOutput {
 public:
   SchemaCompilerErrorTraceOutput(const JSON &instance,
-                                 const Pointer &base = empty_pointer);
+                                 const WeakPointer &base = empty_weak_pointer);
 
   // Prevent accidental copies
   SchemaCompilerErrorTraceOutput(const SchemaCompilerErrorTraceOutput &) =
@@ -670,14 +684,14 @@ class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaCompilerErrorTraceOutput {
 
   struct Entry {
     const std::string message;
-    const Pointer instance_location;
-    const Pointer evaluate_path;
+    const WeakPointer instance_location;
+    const WeakPointer evaluate_path;
   };
 
   auto operator()(const SchemaCompilerEvaluationType type, const bool result,
                   const SchemaCompilerTemplate::value_type &step,
-                  const Pointer &evaluate_path,
-                  const Pointer &instance_location,
+                  const WeakPointer &evaluate_path,
+                  const WeakPointer &instance_location,
                   const JSON &annotation) -> void;
 
   using container_type = typename std::vector<Entry>;
@@ -695,9 +709,9 @@ class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaCompilerErrorTraceOutput {
 #pragma warning(disable : 4251)
 #endif
   const JSON &instance_;
-  const Pointer base_;
+  const WeakPointer base_;
   container_type output;
-  std::set<Pointer> mask;
+  std::set<WeakPointer> mask;
 #if defined(_MSC_VER)
 #pragma warning(default : 4251)
 #endif
@@ -709,7 +723,7 @@ class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaCompilerErrorTraceOutput {
 /// Useful as the building block for producing user-friendly evaluation results.
 auto SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT
 describe(const bool valid, const SchemaCompilerTemplate::value_type &step,
-         const Pointer &evaluate_path, const Pointer &instance_location,
+         const WeakPointer &evaluate_path, const WeakPointer &instance_location,
          const JSON &instance, const JSON &annotation) -> std::string;
 
 /// @ingroup jsonschema_compiler
diff --git a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_error.h b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_error.h
index 76f1b10c..8eef6f8a 100644
--- a/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_error.h
+++ b/vendor/jsontoolkit/src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_error.h
@@ -99,6 +99,20 @@ class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaReferenceError
   std::string message_;
 };
 
+/// @ingroup jsonschema
+/// An error that represents a schema evaluation error event
+class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT SchemaEvaluationError
+    : public std::exception {
+public:
+  SchemaEvaluationError(std::string message) : message_{std::move(message)} {}
+  [[nodiscard]] auto what() const noexcept -> const char * override {
+    return this->message_.c_str();
+  }
+
+private:
+  std::string message_;
+};
+
 #if defined(_MSC_VER)
 #pragma warning(default : 4251 4275)
 #endif