diff --git a/DEPENDENCIES b/DEPENDENCIES
index e6b1b9388..bdc3067a4 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -1,3 +1,3 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core 56eab6ef118e9731df539d3a507db1c23241f911
+core https://github.com/sourcemeta/core 57e8c91ed68e3ee903526fd2f45cb16ca46759d8
 bootstrap https://github.com/twbs/bootstrap 1a6fdfae6be09b09eaced8f0e442ca6f7680a61e
diff --git a/test/packaging/find_package/CMakeLists.txt b/test/packaging/find_package/CMakeLists.txt
index d40a5e990..6194ebcd4 100644
--- a/test/packaging/find_package/CMakeLists.txt
+++ b/test/packaging/find_package/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)
 project(jsonbinpack_hello VERSION 0.0.1 LANGUAGES CXX)
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 find_package(JSONBinPack REQUIRED)
diff --git a/vendor/core/CMakeLists.txt b/vendor/core/CMakeLists.txt
index fdbd3feee..c12369e28 100644
--- a/vendor/core/CMakeLists.txt
+++ b/vendor/core/CMakeLists.txt
@@ -16,6 +16,7 @@ option(SOURCEMETA_CORE_TIME "Build the Sourcemeta Core time library" ON)
 option(SOURCEMETA_CORE_CRYPTO "Build the Sourcemeta Core Crypto library" ON)
 option(SOURCEMETA_CORE_CRYPTO_USE_SYSTEM_OPENSSL "Use system OpenSSL for the Sourcemeta Core Crypto library" OFF)
 option(SOURCEMETA_CORE_REGEX "Build the Sourcemeta Core Regex library" ON)
+option(SOURCEMETA_CORE_IP "Build the Sourcemeta Core IP library" ON)
 option(SOURCEMETA_CORE_URI "Build the Sourcemeta Core URI library" ON)
 option(SOURCEMETA_CORE_URITEMPLATE "Build the Sourcemeta Core URI Template library" ON)
 option(SOURCEMETA_CORE_JSON "Build the Sourcemeta Core JSON library" ON)
@@ -114,6 +115,10 @@ if(SOURCEMETA_CORE_REGEX)
   add_subdirectory(src/core/regex)
 endif()
 
+if(SOURCEMETA_CORE_IP)
+  add_subdirectory(src/core/ip)
+endif()
+
 if(SOURCEMETA_CORE_URI)
   add_subdirectory(src/core/uri)
 endif()
@@ -233,6 +238,10 @@ if(SOURCEMETA_CORE_TESTS)
     add_subdirectory(test/regex)
   endif()
 
+  if(SOURCEMETA_CORE_IP)
+    add_subdirectory(test/ip)
+  endif()
+
   if(SOURCEMETA_CORE_URI)
     add_subdirectory(test/uri)
   endif()
diff --git a/vendor/core/cmake/common/defaults.cmake b/vendor/core/cmake/common/defaults.cmake
index 93c8bc140..bb2ce6f7b 100644
--- a/vendor/core/cmake/common/defaults.cmake
+++ b/vendor/core/cmake/common/defaults.cmake
@@ -1,6 +1,6 @@
 # Standards (sane modern defaults)
 if("CXX" IN_LIST SOURCEMETA_LANGUAGES)
-  set(CMAKE_CXX_STANDARD 20)
+  set(CMAKE_CXX_STANDARD 23)
 endif()
 if("C" IN_LIST SOURCEMETA_LANGUAGES)
   set(CMAKE_C_STANDARD 11)
diff --git a/vendor/core/cmake/common/targets/executable.cmake b/vendor/core/cmake/common/targets/executable.cmake
index 2066d39a1..63f61cc2e 100644
--- a/vendor/core/cmake/common/targets/executable.cmake
+++ b/vendor/core/cmake/common/targets/executable.cmake
@@ -51,8 +51,12 @@ function(sourcemeta_executable)
     target_link_options(${TARGET_NAME} PRIVATE /guard:cf /CETCOMPAT)
   endif()
 
-  # Linux-specific ELF linker hardening options
+  # Linux-specific ELF linker hardening and compatibility options
   if(SOURCEMETA_OS_LINUX AND (SOURCEMETA_COMPILER_LLVM OR SOURCEMETA_COMPILER_GCC))
+    # Maximize compatibility of pre-built binaries across Linux distros
+    if(NOT BUILD_SHARED_LIBS)
+      target_link_options(${TARGET_NAME} PRIVATE -static-libstdc++ -static-libgcc)
+    endif()
     target_link_options(${TARGET_NAME} PRIVATE
       "LINKER:-z,nodlopen"
       "LINKER:-z,noexecstack"
diff --git a/vendor/core/config.cmake.in b/vendor/core/config.cmake.in
index e311a1b50..0f93f6c68 100644
--- a/vendor/core/config.cmake.in
+++ b/vendor/core/config.cmake.in
@@ -14,6 +14,7 @@ if(NOT SOURCEMETA_CORE_COMPONENTS)
   list(APPEND SOURCEMETA_CORE_COMPONENTS time)
   list(APPEND SOURCEMETA_CORE_COMPONENTS crypto)
   list(APPEND SOURCEMETA_CORE_COMPONENTS regex)
+  list(APPEND SOURCEMETA_CORE_COMPONENTS ip)
   list(APPEND SOURCEMETA_CORE_COMPONENTS uri)
   list(APPEND SOURCEMETA_CORE_COMPONENTS uritemplate)
   list(APPEND SOURCEMETA_CORE_COMPONENTS json)
@@ -59,7 +60,10 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
   elseif(component STREQUAL "regex")
     find_dependency(PCRE2 CONFIG)
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_regex.cmake")
+  elseif(component STREQUAL "ip")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
   elseif(component STREQUAL "uri")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
   elseif(component STREQUAL "uritemplate")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
@@ -78,6 +82,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_jsonl.cmake")
   elseif(component STREQUAL "jsonpointer")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_regex.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_numeric.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
@@ -85,6 +90,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_json.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_jsonpointer.cmake")
   elseif(component STREQUAL "jsonschema")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_numeric.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
@@ -95,6 +101,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
   elseif(component STREQUAL "yaml")
     find_dependency(PCRE2 CONFIG)
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_regex.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_numeric.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
@@ -109,6 +116,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_preprocessor.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_html.cmake")
   elseif(component STREQUAL "alterschema")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_numeric.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
@@ -120,6 +128,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_jsonschema.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_alterschema.cmake")
   elseif(component STREQUAL "editorschema")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_ip.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_uri.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_numeric.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_io.cmake")
diff --git a/vendor/core/src/core/crypto/crypto_sha256.cc b/vendor/core/src/core/crypto/crypto_sha256.cc
index e4be5eb31..08f4e62c5 100644
--- a/vendor/core/src/core/crypto/crypto_sha256.cc
+++ b/vendor/core/src/core/crypto/crypto_sha256.cc
@@ -41,6 +41,8 @@ auto sha256(const std::string_view input, std::ostream &output) -> void {
 
   EVP_MD_CTX_free(context);
 
+  // TODO: Use std::views::enumerate once libc++ supports it
+  // (__cpp_lib_ranges_enumerate)
   for (std::uint64_t index = 0; index < 32u; ++index) {
     output.put(HEX_DIGITS[(digest[index] >> 4u) & 0x0fu]);
     output.put(HEX_DIGITS[digest[index] & 0x0fu]);
diff --git a/vendor/core/src/core/html/escape.cc b/vendor/core/src/core/html/escape.cc
index 6b3097a1a..57ffbc822 100644
--- a/vendor/core/src/core/html/escape.cc
+++ b/vendor/core/src/core/html/escape.cc
@@ -5,8 +5,7 @@
 namespace sourcemeta::core {
 
 auto html_escape(std::string &text) -> void {
-  std::size_t write_position{0};
-  std::size_t original_size{text.size()};
+  const std::size_t original_size{text.size()};
 
   // First pass: count how much space we need
   std::size_t required_size{0};
@@ -35,62 +34,64 @@ auto html_escape(std::string &text) -> void {
     return;
   }
 
-  // Resize string to accommodate escaped characters
-  text.resize(required_size);
-
-  // Second pass: work backwards to avoid overwriting data
-  std::size_t read_position{original_size};
-  write_position = required_size;
-
-  while (read_position > 0) {
-    --read_position;
-    char character = text[read_position];
-
-    switch (character) {
-      case '&':
-        write_position -= 5;
-        text[write_position] = '&';
-        text[write_position + 1] = 'a';
-        text[write_position + 2] = 'm';
-        text[write_position + 3] = 'p';
-        text[write_position + 4] = ';';
-        break;
-      case '<':
-        write_position -= 4;
-        text[write_position] = '&';
-        text[write_position + 1] = 'l';
-        text[write_position + 2] = 't';
-        text[write_position + 3] = ';';
-        break;
-      case '>':
-        write_position -= 4;
-        text[write_position] = '&';
-        text[write_position + 1] = 'g';
-        text[write_position + 2] = 't';
-        text[write_position + 3] = ';';
-        break;
-      case '"':
-        write_position -= 6;
-        text[write_position] = '&';
-        text[write_position + 1] = 'q';
-        text[write_position + 2] = 'u';
-        text[write_position + 3] = 'o';
-        text[write_position + 4] = 't';
-        text[write_position + 5] = ';';
-        break;
-      case '\'':
-        write_position -= 5;
-        text[write_position] = '&';
-        text[write_position + 1] = '#';
-        text[write_position + 2] = '3';
-        text[write_position + 3] = '9';
-        text[write_position + 4] = ';';
-        break;
-      default:
-        --write_position;
-        text[write_position] = character;
-    }
-  }
+  // Write escaped characters backwards to avoid overwriting unprocessed data
+  text.resize_and_overwrite(required_size,
+                            [original_size](char *buffer, std::size_t count) {
+                              auto read_position = original_size;
+                              auto write_position = count;
+
+                              while (read_position > 0) {
+                                --read_position;
+                                const auto character = buffer[read_position];
+
+                                switch (character) {
+                                  case '&':
+                                    write_position -= 5;
+                                    buffer[write_position] = '&';
+                                    buffer[write_position + 1] = 'a';
+                                    buffer[write_position + 2] = 'm';
+                                    buffer[write_position + 3] = 'p';
+                                    buffer[write_position + 4] = ';';
+                                    break;
+                                  case '<':
+                                    write_position -= 4;
+                                    buffer[write_position] = '&';
+                                    buffer[write_position + 1] = 'l';
+                                    buffer[write_position + 2] = 't';
+                                    buffer[write_position + 3] = ';';
+                                    break;
+                                  case '>':
+                                    write_position -= 4;
+                                    buffer[write_position] = '&';
+                                    buffer[write_position + 1] = 'g';
+                                    buffer[write_position + 2] = 't';
+                                    buffer[write_position + 3] = ';';
+                                    break;
+                                  case '"':
+                                    write_position -= 6;
+                                    buffer[write_position] = '&';
+                                    buffer[write_position + 1] = 'q';
+                                    buffer[write_position + 2] = 'u';
+                                    buffer[write_position + 3] = 'o';
+                                    buffer[write_position + 4] = 't';
+                                    buffer[write_position + 5] = ';';
+                                    break;
+                                  case '\'':
+                                    write_position -= 5;
+                                    buffer[write_position] = '&';
+                                    buffer[write_position + 1] = '#';
+                                    buffer[write_position + 2] = '3';
+                                    buffer[write_position + 3] = '9';
+                                    buffer[write_position + 4] = ';';
+                                    break;
+                                  default:
+                                    --write_position;
+                                    buffer[write_position] = character;
+                                }
+                              }
+
+                              return count;
+                            });
 }
 
 static auto needs_escape(const std::string_view input) -> bool {
diff --git a/vendor/core/src/core/html/include/sourcemeta/core/html_buffer.h b/vendor/core/src/core/html/include/sourcemeta/core/html_buffer.h
index 7c0c9f3ca..ae8a4fa14 100644
--- a/vendor/core/src/core/html/include/sourcemeta/core/html_buffer.h
+++ b/vendor/core/src/core/html/include/sourcemeta/core/html_buffer.h
@@ -48,7 +48,7 @@ class SOURCEMETA_CORE_HTML_EXPORT HTMLBuffer {
 
     const auto remaining{
         this->cursor_ ? static_cast<std::size_t>(this->end_ - this->cursor_)
-                      : std::size_t{0}};
+                      : 0uz};
     if (remaining < length) [[unlikely]] {
       this->grow(length);
     }
diff --git a/vendor/core/src/core/html/writer.cc b/vendor/core/src/core/html/writer.cc
index 23087b79d..ee6775a40 100644
--- a/vendor/core/src/core/html/writer.cc
+++ b/vendor/core/src/core/html/writer.cc
@@ -9,8 +9,7 @@ auto HTMLBuffer::grow(const std::size_t needed) -> void {
       this->cursor_
           ? static_cast<std::size_t>(this->cursor_ - this->buffer_.data())
           : 0};
-  auto new_capacity{this->buffer_.empty() ? std::size_t{1024}
-                                          : this->buffer_.size() * 2};
+  auto new_capacity{this->buffer_.empty() ? 1024uz : this->buffer_.size() * 2};
   while (new_capacity < current_size + needed) {
     new_capacity *= 2;
   }
diff --git a/vendor/core/src/core/ip/CMakeLists.txt b/vendor/core/src/core/ip/CMakeLists.txt
new file mode 100644
index 000000000..3c2fdd7e6
--- /dev/null
+++ b/vendor/core/src/core/ip/CMakeLists.txt
@@ -0,0 +1,6 @@
+sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME ip
+  SOURCES ipv4.cc ipv6.cc)
+
+if(SOURCEMETA_CORE_INSTALL)
+  sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME ip)
+endif()
diff --git a/vendor/core/src/core/ip/include/sourcemeta/core/ip.h b/vendor/core/src/core/ip/include/sourcemeta/core/ip.h
new file mode 100644
index 000000000..72860f6b9
--- /dev/null
+++ b/vendor/core/src/core/ip/include/sourcemeta/core/ip.h
@@ -0,0 +1,54 @@
+#ifndef SOURCEMETA_CORE_IP_H_
+#define SOURCEMETA_CORE_IP_H_
+
+#ifndef SOURCEMETA_CORE_IP_EXPORT
+#include <sourcemeta/core/ip_export.h>
+#endif
+
+#include <string_view> // std::string_view
+
+/// @defgroup ip IP
+/// @brief IPv4 (RFC 3986) and IPv6 (RFC 3986, RFC 4291) address validation.
+///
+/// This functionality is included as follows:
+///
+/// ```cpp
+/// #include <sourcemeta/core/ip.h>
+/// ```
+
+namespace sourcemeta::core {
+
+/// @ingroup ip
+/// Check whether the given string is a valid IPv4 address per RFC 3986
+/// Section 3.2.2. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/ip.h>
+///
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::is_ipv4("192.168.1.1"));
+/// assert(!sourcemeta::core::is_ipv4("999.0.0.1"));
+/// ```
+SOURCEMETA_CORE_IP_EXPORT
+auto is_ipv4(std::string_view address) -> bool;
+
+/// @ingroup ip
+/// Check whether the given string is a valid IPv6 address per RFC 3986
+/// Section 3.2.2 and RFC 4291 Section 2.2. The input must not include
+/// surrounding brackets. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/ip.h>
+///
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::is_ipv6("2001:db8::1"));
+/// assert(!sourcemeta::core::is_ipv6("not an address"));
+/// ```
+SOURCEMETA_CORE_IP_EXPORT
+auto is_ipv6(std::string_view address) -> bool;
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/ip/ipv4.cc b/vendor/core/src/core/ip/ipv4.cc
new file mode 100644
index 000000000..656935a4c
--- /dev/null
+++ b/vendor/core/src/core/ip/ipv4.cc
@@ -0,0 +1,56 @@
+#include <sourcemeta/core/ip.h>
+
+namespace sourcemeta::core {
+
+static constexpr auto is_digit(const char character) -> bool {
+  return character >= '0' && character <= '9';
+}
+
+auto is_ipv4(const std::string_view address) -> bool {
+  if (address.empty()) {
+    return false;
+  }
+
+  std::string_view::size_type position{0};
+  unsigned int octet_count{0};
+
+  while (octet_count < 4) {
+    if (position >= address.size()) {
+      return false;
+    }
+
+    if (!is_digit(address[position])) {
+      return false;
+    }
+
+    const auto octet_start{position};
+    unsigned int value{0};
+    while (position < address.size() && is_digit(address[position])) {
+      value = value * 10 + static_cast<unsigned int>(address[position] - '0');
+      position += 1;
+    }
+
+    const auto octet_length{position - octet_start};
+
+    if (octet_length > 1 && address[octet_start] == '0') {
+      return false;
+    }
+
+    if (octet_length > 3 || value > 255) {
+      return false;
+    }
+
+    octet_count += 1;
+
+    if (octet_count < 4) {
+      if (position >= address.size() || address[position] != '.') {
+        return false;
+      }
+      position += 1;
+    }
+  }
+
+  return position == address.size();
+}
+
+} // namespace sourcemeta::core
diff --git a/vendor/core/src/core/ip/ipv6.cc b/vendor/core/src/core/ip/ipv6.cc
new file mode 100644
index 000000000..099be9bdb
--- /dev/null
+++ b/vendor/core/src/core/ip/ipv6.cc
@@ -0,0 +1,112 @@
+#include <sourcemeta/core/ip.h>
+
+#include <array>   // std::array
+#include <cstdint> // std::uint8_t
+
+namespace sourcemeta::core {
+
+static constexpr auto make_hex_table() -> std::array<bool, 256> {
+  std::array<bool, 256> table{};
+  for (auto index{0u}; index < 256; index++) {
+    table[index] = (index >= '0' && index <= '9') ||
+                   (index >= 'a' && index <= 'f') ||
+                   (index >= 'A' && index <= 'F');
+  }
+  return table;
+}
+
+static constexpr auto HEX_TABLE{make_hex_table()};
+
+static constexpr auto is_hex_digit(const char character) -> bool {
+  return HEX_TABLE[static_cast<std::uint8_t>(character)];
+}
+
+auto is_ipv6(const std::string_view address) -> bool {
+  if (address.empty()) {
+    return false;
+  }
+
+  const auto size{address.size()};
+
+  if (address.front() == '[' || address.back() == ']') {
+    return false;
+  }
+
+  const auto double_colon{address.find("::")};
+  const bool has_compression{double_colon != std::string_view::npos};
+
+  if (has_compression &&
+      address.find("::", double_colon + 2) != std::string_view::npos) {
+    return false;
+  }
+
+  if (address.front() == ':' && (!has_compression || double_colon != 0)) {
+    return false;
+  }
+  if (address.back() == ':' &&
+      (!has_compression || double_colon + 1 != size - 1)) {
+    return false;
+  }
+
+  unsigned int group_count{0};
+  std::string_view::size_type position{0};
+
+  while (position < size) {
+    if (has_compression && position == double_colon) {
+      position += 2;
+      continue;
+    }
+
+    const auto group_start{position};
+    unsigned int hex_count{0};
+    bool found_dot{false};
+
+    while (position < size) {
+      const auto character{address[position]};
+      if (character == ':') {
+        break;
+      }
+      if (character == '.') {
+        found_dot = true;
+        break;
+      }
+      if (!is_hex_digit(character)) {
+        return false;
+      }
+      hex_count += 1;
+      position += 1;
+    }
+
+    if (found_dot) {
+      if (!is_ipv4(address.substr(group_start))) {
+        return false;
+      }
+      group_count += 2;
+      break;
+    }
+
+    if (hex_count == 0 || hex_count > 4) {
+      return false;
+    }
+
+    group_count += 1;
+
+    if (position < size && address[position] == ':') {
+      if (has_compression && position == double_colon) {
+        continue;
+      }
+      position += 1;
+      if (position >= size) {
+        return false;
+      }
+    }
+  }
+
+  if (has_compression) {
+    return group_count < 8;
+  }
+
+  return group_count == 8;
+}
+
+} // namespace sourcemeta::core
diff --git a/vendor/core/src/core/json/include/sourcemeta/core/json.h b/vendor/core/src/core/json/include/sourcemeta/core/json.h
index 98c7231c4..99148b140 100644
--- a/vendor/core/src/core/json/include/sourcemeta/core/json.h
+++ b/vendor/core/src/core/json/include/sourcemeta/core/json.h
@@ -13,12 +13,14 @@
 
 #include <sourcemeta/core/preprocessor.h>
 
-#include <cstdint>          // std::uint64_t
-#include <filesystem>       // std::filesystem
+#include <cstdint>    // std::uint64_t
+#include <filesystem> // std::filesystem
+#include <format> // std::formatter, std::format_context, std::format_parse_context, std::format_to
 #include <fstream>          // std::basic_ifstream
 #include <initializer_list> // std::initializer_list
 #include <istream>          // std::basic_istream
 #include <ostream>          // std::basic_ostream
+#include <sstream>          // std::ostringstream
 #include <string>           // std::basic_string
 
 /// @defgroup json JSON
@@ -303,4 +305,32 @@ make_set(std::initializer_list<JSON::Type> types) -> JSON::TypeSet {
 
 } // namespace sourcemeta::core
 
+template <> struct std::formatter<sourcemeta::core::JSON> {
+  constexpr auto parse(std::format_parse_context &context)
+      -> decltype(context.begin()) {
+    return context.begin();
+  }
+
+  auto format(const sourcemeta::core::JSON &value,
+              std::format_context &context) const -> decltype(context.out()) {
+    std::ostringstream stream;
+    stream << value;
+    return std::format_to(context.out(), "{}", stream.str());
+  }
+};
+
+template <> struct std::formatter<sourcemeta::core::JSON::Type> {
+  constexpr auto parse(std::format_parse_context &context)
+      -> decltype(context.begin()) {
+    return context.begin();
+  }
+
+  auto format(const sourcemeta::core::JSON::Type value,
+              std::format_context &context) const -> decltype(context.out()) {
+    std::ostringstream stream;
+    stream << value;
+    return std::format_to(context.out(), "{}", stream.str());
+  }
+};
+
 #endif
diff --git a/vendor/core/src/core/json/include/sourcemeta/core/json_auto.h b/vendor/core/src/core/json/include/sourcemeta/core/json_auto.h
index 813c829d1..1e2bb6179 100644
--- a/vendor/core/src/core/json/include/sourcemeta/core/json_auto.h
+++ b/vendor/core/src/core/json/include/sourcemeta/core/json_auto.h
@@ -3,27 +3,24 @@
 
 #include <sourcemeta/core/json_value.h>
 
-#include <algorithm>  // std::sort
-#include <bitset>     // std::bitset
-#include <cassert>    // assert
-#include <chrono>     // std::chrono
-#include <concepts>   // std::same_as, std::constructible_from
+#include <algorithm> // std::sort
+#include <bitset>    // std::bitset
+#include <cassert>   // assert
+#include <chrono>    // std::chrono
+#include <concepts> // std::same_as, std::constructible_from, std::invocable, std::invocable
 #include <filesystem> // std::filesystem
 #include <functional> // std::function
 #include <optional>   // std::optional, std::nullopt, std::bad_optional_access
 #include <tuple> // std::tuple, std::apply, std::tuple_element_t, std::tuple_size, std::tuple_size_v
-#include <type_traits> // std::false_type, std::true_type, std::void_t, std::is_enum_v, std::underlying_type_t, std::is_same_v, std::is_base_of_v, std::remove_cvref_t
+#include <type_traits> // std::false_type, std::true_type, std::is_enum_v, std::underlying_type_t, std::is_same_v, std::is_base_of_v, std::remove_cvref_t
 #include <utility> // std::pair, std:::make_index_sequence, std::index_sequence
 #include <variant> // std::variant, std::variant_size_v, std::variant_alternative_t, std::visit
 
 namespace sourcemeta::core {
 
 /// @ingroup json
-template <typename, typename = void>
-struct json_auto_has_mapped_type : std::false_type {};
 template <typename T>
-struct json_auto_has_mapped_type<T, std::void_t<typename T::mapped_type>>
-    : std::true_type {};
+concept json_auto_has_mapped_type = requires { typename T::mapped_type; };
 
 /// @ingroup json
 template <typename T> struct json_auto_is_basic_string : std::false_type {};
@@ -57,14 +54,10 @@ concept json_auto_has_method_to = requires(const T value) {
 /// @ingroup json
 /// Container-like classes can opt-out from automatic JSON
 /// serialisation by setting `using json_auto = std::false_type;`
-template <typename, typename = void>
-struct json_auto_supports_auto_impl : std::true_type {};
-template <typename T>
-struct json_auto_supports_auto_impl<T, std::void_t<typename T::json_auto>>
-    : std::bool_constant<
-          !std::is_same_v<typename T::json_auto, std::false_type>> {};
 template <typename T>
-concept json_auto_supports_auto = json_auto_supports_auto_impl<T>::value;
+concept json_auto_supports_auto = !requires {
+  typename T::json_auto;
+} || !std::is_same_v<typename T::json_auto, std::false_type>;
 
 /// @ingroup json
 template <typename T>
@@ -74,7 +67,7 @@ concept json_auto_list_like =
       typename T::const_iterator;
       { type.cbegin() } -> std::same_as<typename T::const_iterator>;
       { type.cend() } -> std::same_as<typename T::const_iterator>;
-    } && json_auto_supports_auto<T> && !json_auto_has_mapped_type<T>::value &&
+    } && json_auto_supports_auto<T> && !json_auto_has_mapped_type<T> &&
     !json_auto_has_method_from<T> && !json_auto_has_method_to<T> &&
     !json_auto_is_basic_string<T>::value;
 
@@ -87,19 +80,14 @@ concept json_auto_map_like =
       typename T::key_type;
       { type.cbegin() } -> std::same_as<typename T::const_iterator>;
       { type.cend() } -> std::same_as<typename T::const_iterator>;
-    } && json_auto_supports_auto<T> && json_auto_has_mapped_type<T>::value &&
+    } && json_auto_supports_auto<T> && json_auto_has_mapped_type<T> &&
     !json_auto_has_method_from<T> && !json_auto_has_method_to<T> &&
     std::is_same_v<typename T::key_type, JSON::String>;
 
-/// @ingroup json
-template <typename, typename = void>
-struct json_auto_has_reverse_iterator : std::false_type {};
-
 /// @ingroup json
 template <typename T>
-struct json_auto_has_reverse_iterator<T,
-                                      std::void_t<typename T::reverse_iterator>>
-    : std::true_type {};
+concept json_auto_has_reverse_iterator =
+    requires { typename T::reverse_iterator; };
 
 /// @ingroup json
 template <typename T> struct json_auto_is_pair : std::false_type {};
@@ -393,7 +381,7 @@ auto to_json(typename T::const_iterator begin, typename T::const_iterator end)
   }
 
   // To guarantee ordering across implementations
-  if constexpr (!json_auto_has_reverse_iterator<T>::value) {
+  if constexpr (!json_auto_has_reverse_iterator<T>) {
     std::sort(result.as_array().begin(), result.as_array().end());
   }
 
@@ -401,11 +389,10 @@ auto to_json(typename T::const_iterator begin, typename T::const_iterator end)
 }
 
 /// @ingroup json
-template <json_auto_list_like T>
-auto to_json(
-    typename T::const_iterator begin, typename T::const_iterator end,
-    const std::function<JSON(const typename T::value_type &)> &callback)
-    -> JSON {
+template <json_auto_list_like T,
+          std::invocable<const typename T::value_type &> F>
+auto to_json(typename T::const_iterator begin, typename T::const_iterator end,
+             const F &callback) -> JSON {
   // TODO: Extend `make_array` to optionally take iterators, etc
   auto result{JSON::make_array()};
   for (auto iterator = begin; iterator != end; ++iterator) {
@@ -413,7 +400,7 @@ auto to_json(
   }
 
   // To guarantee ordering across implementations
-  if constexpr (!json_auto_has_reverse_iterator<T>::value) {
+  if constexpr (!json_auto_has_reverse_iterator<T>) {
     std::sort(result.as_array().begin(), result.as_array().end());
   }
 
@@ -426,11 +413,9 @@ template <json_auto_list_like T> auto to_json(const T &value) -> JSON {
 }
 
 /// @ingroup json
-template <json_auto_list_like T>
-auto to_json(
-    const T &value,
-    const std::function<JSON(const typename T::value_type &)> &callback)
-    -> JSON {
+template <json_auto_list_like T,
+          std::invocable<const typename T::value_type &> F>
+auto to_json(const T &value, const F &callback) -> JSON {
   return to_json<T>(value.cbegin(), value.cend(), callback);
 }
 
@@ -513,11 +498,10 @@ template <json_auto_map_like T> auto to_json(const T &value) -> JSON {
 }
 
 /// @ingroup json
-template <json_auto_map_like T>
-auto to_json(
-    typename T::const_iterator begin, typename T::const_iterator end,
-    const std::function<JSON(const typename T::mapped_type &)> &callback)
-    -> JSON {
+template <json_auto_map_like T,
+          std::invocable<const typename T::mapped_type &> F>
+auto to_json(typename T::const_iterator begin, typename T::const_iterator end,
+             const F &callback) -> JSON {
   auto result{JSON::make_object()};
   for (auto iterator = begin; iterator != end; ++iterator) {
     result.assign(iterator->first, callback(iterator->second));
@@ -570,11 +554,9 @@ auto from_json(
 }
 
 /// @ingroup json
-template <json_auto_map_like T>
-auto to_json(
-    const T &value,
-    const std::function<JSON(const typename T::mapped_type &)> &callback)
-    -> JSON {
+template <json_auto_map_like T,
+          std::invocable<const typename T::mapped_type &> F>
+auto to_json(const T &value, const F &callback) -> JSON {
   return to_json<T>(value.cbegin(), value.cend(), callback);
 }
 
diff --git a/vendor/core/src/core/json/include/sourcemeta/core/json_object.h b/vendor/core/src/core/json/include/sourcemeta/core/json_object.h
index 14e692c6f..c364faaa1 100644
--- a/vendor/core/src/core/json/include/sourcemeta/core/json_object.h
+++ b/vendor/core/src/core/json/include/sourcemeta/core/json_object.h
@@ -6,7 +6,7 @@
 #include <cstddef>          // std::size_t
 #include <initializer_list> // std::initializer_list
 #include <iterator>         // std::advance
-#include <utility>          // std::pair, std::move
+#include <utility>          // std::pair, std::move, std::unreachable
 #include <vector>           // std::vector
 
 namespace sourcemeta::core {
@@ -220,12 +220,7 @@ template <typename Key, typename Value, typename Hash> class JSONObject {
       }
     }
 
-// See https://en.cppreference.com/w/cpp/utility/unreachable
-#if defined(_MSC_VER) && !defined(__clang__)
-    __assume(false);
-#else
-    __builtin_unreachable();
-#endif
+    std::unreachable();
   }
 
   /// Access an object entry by its key name
@@ -247,12 +242,7 @@ template <typename Key, typename Value, typename Hash> class JSONObject {
       }
     }
 
-// See https://en.cppreference.com/w/cpp/utility/unreachable
-#if defined(_MSC_VER) && !defined(__clang__)
-    __assume(false);
-#else
-    __builtin_unreachable();
-#endif
+    std::unreachable();
   }
 
   /// Try to access an object entry by its underlying positional index
diff --git a/vendor/core/src/core/json/include/sourcemeta/core/json_value.h b/vendor/core/src/core/json/include/sourcemeta/core/json_value.h
index cb9045c59..47ffa2463 100644
--- a/vendor/core/src/core/json/include/sourcemeta/core/json_value.h
+++ b/vendor/core/src/core/json/include/sourcemeta/core/json_value.h
@@ -25,7 +25,7 @@
 #include <sstream>          // std::basic_istringstream
 #include <string>           // std::basic_string, std::char_traits
 #include <string_view>      // std::basic_string_view
-#include <type_traits>      // std::enable_if_t, std::is_same_v
+#include <type_traits>      // std::is_same_v
 #include <utility>          // std::pair
 
 namespace sourcemeta::core {
@@ -683,6 +683,9 @@ class SOURCEMETA_CORE_JSON_EXPORT JSON {
   ///                           << "\n";
   ///               });
   /// ```
+  // TODO: Merge const/non-const overloads of as_array, as_object, at, front,
+  // back using deducing this once Apple Clang supports it
+  // (__cpp_explicit_this_parameter)
   [[nodiscard]] SOURCEMETA_FORCEINLINE inline auto as_array() const noexcept
       -> const Array & {
     assert(this->is_array());
diff --git a/vendor/core/src/core/json/json_value.cc b/vendor/core/src/core/json/json_value.cc
index 1d5bf2a9c..0feab582a 100644
--- a/vendor/core/src/core/json/json_value.cc
+++ b/vendor/core/src/core/json/json_value.cc
@@ -1,19 +1,19 @@
 #include <sourcemeta/core/json_array.h>
 #include <sourcemeta/core/json_value.h>
 
-#include <algorithm>        // std::find
+#include <algorithm>        // std::ranges::contains, std::ranges::fold_left
 #include <cassert>          // assert
 #include <cmath>            // std::isinf, std::isnan, std::modf
 #include <cstddef>          // std::size_t
 #include <cstdint>          // std::int64_t
 #include <functional>       // std::reference_wrapper
 #include <initializer_list> // std::initializer_list
-#include <numeric>          // std::transform
+#include <memory>           // std::construct_at
 #include <sstream>          // std::basic_istringstream
 #include <stdexcept>        // std::invalid_argument
 #include <string>           // std::to_string
 #include <string_view>      // std::basic_string_view
-#include <utility>          // std::move
+#include <utility>          // std::exchange, std::move
 #include <vector>           // std::vector
 
 namespace sourcemeta::core {
@@ -52,16 +52,16 @@ JSON::JSON(const bool value) : current_type{Type::Boolean} {
 JSON::JSON(const std::nullptr_t) {}
 
 JSON::JSON(const String &value) : current_type{Type::String} {
-  new (&this->data_string) String{value};
+  std::construct_at(&this->data_string, value);
 }
 
 JSON::JSON(const std::basic_string_view<Char, CharTraits> &value)
     : current_type{Type::String} {
-  new (&this->data_string) String{value};
+  std::construct_at(&this->data_string, value);
 }
 
 JSON::JSON(const Char *const value) : current_type{Type::String} {
-  new (&this->data_string) String{value};
+  std::construct_at(&this->data_string, value);
 }
 
 JSON::JSON(std::initializer_list<JSON> values) : current_type{Type::Array} {
@@ -77,20 +77,20 @@ JSON::JSON(std::initializer_list<JSON> values) : current_type{Type::Array} {
     return;
   }
 #endif
-  new (&this->data_array) Array{values};
+  std::construct_at(&this->data_array, values);
 }
 
 JSON::JSON(const Array &value) : current_type{Type::Array} {
-  new (&this->data_array) Array{value};
+  std::construct_at(&this->data_array, value);
 }
 
 JSON::JSON(std::initializer_list<typename Object::pair_value_type> values)
     : current_type{Type::Object} {
-  new (&this->data_object) Object{values};
+  std::construct_at(&this->data_object, values);
 }
 
 JSON::JSON(const Object &value) : current_type{Type::Object} {
-  new (&this->data_object) Object{value};
+  std::construct_at(&this->data_object, value);
 }
 
 JSON::JSON(const Decimal &value) : current_type{Type::Decimal} {
@@ -121,13 +121,13 @@ JSON::JSON(const JSON &other) : current_type{other.current_type} {
       this->data_real = other.data_real;
       break;
     case Type::String:
-      new (&this->data_string) String{other.data_string};
+      std::construct_at(&this->data_string, other.data_string);
       break;
     case Type::Array:
-      new (&this->data_array) Array{other.data_array};
+      std::construct_at(&this->data_array, other.data_array);
       break;
     case Type::Object:
-      new (&this->data_object) Object{other.data_object};
+      std::construct_at(&this->data_object, other.data_object);
       break;
     case Type::Decimal:
       this->data_decimal = new Decimal{*other.data_decimal};
@@ -149,20 +149,19 @@ JSON::JSON(JSON &&other) noexcept : current_type{other.current_type} {
       this->data_real = other.data_real;
       break;
     case Type::String:
-      new (&this->data_string) String{std::move(other.data_string)};
+      std::construct_at(&this->data_string, std::move(other.data_string));
       other.current_type = Type::Null;
       break;
     case Type::Array:
-      new (&this->data_array) Array{std::move(other.data_array)};
+      std::construct_at(&this->data_array, std::move(other.data_array));
       other.current_type = Type::Null;
       break;
     case Type::Object:
-      new (&this->data_object) Object{std::move(other.data_object)};
+      std::construct_at(&this->data_object, std::move(other.data_object));
       other.current_type = Type::Null;
       break;
     case Type::Decimal:
-      this->data_decimal = other.data_decimal;
-      other.data_decimal = nullptr;
+      this->data_decimal = std::exchange(other.data_decimal, nullptr);
       other.current_type = Type::Null;
       break;
     default:
@@ -184,13 +183,13 @@ auto JSON::operator=(const JSON &other) -> JSON & {
       this->data_real = other.data_real;
       break;
     case Type::String:
-      new (&this->data_string) String{other.data_string};
+      std::construct_at(&this->data_string, other.data_string);
       break;
     case Type::Array:
-      new (&this->data_array) Array{other.data_array};
+      std::construct_at(&this->data_array, other.data_array);
       break;
     case Type::Object:
-      new (&this->data_object) Object{other.data_object};
+      std::construct_at(&this->data_object, other.data_object);
       break;
     case Type::Decimal:
       this->data_decimal = new Decimal{*other.data_decimal};
@@ -216,20 +215,19 @@ auto JSON::operator=(JSON &&other) noexcept -> JSON & {
       this->data_real = other.data_real;
       break;
     case Type::String:
-      new (&this->data_string) String{std::move(other.data_string)};
+      std::construct_at(&this->data_string, std::move(other.data_string));
       other.current_type = Type::Null;
       break;
     case Type::Array:
-      new (&this->data_array) Array{std::move(other.data_array)};
+      std::construct_at(&this->data_array, std::move(other.data_array));
       other.current_type = Type::Null;
       break;
     case Type::Object:
-      new (&this->data_object) Object{std::move(other.data_object)};
+      std::construct_at(&this->data_object, std::move(other.data_object));
       other.current_type = Type::Null;
       break;
     case Type::Decimal:
-      this->data_decimal = other.data_decimal;
-      other.data_decimal = nullptr;
+      this->data_decimal = std::exchange(other.data_decimal, nullptr);
       other.current_type = Type::Null;
       break;
     default:
@@ -455,18 +453,17 @@ auto JSON::operator-=(const JSON &substractive) -> JSON & {
   // which we are not taking into account here, as its typically
   // implementation dependent. This function is just a rough estimate.
   if (this->is_object()) {
-    return std::accumulate(this->as_object().cbegin(), this->as_object().cend(),
-                           static_cast<std::uint64_t>(0),
-                           [](const std::uint64_t accumulator,
-                              const typename Object::value_type &pair) {
-                             return accumulator +
-                                    (pair.first.size() * sizeof(Char)) +
-                                    pair.second.estimated_byte_size();
-                           });
+    return std::ranges::fold_left(this->as_object(),
+                                  static_cast<std::uint64_t>(0),
+                                  [](const std::uint64_t accumulator,
+                                     const typename Object::value_type &pair) {
+                                    return accumulator +
+                                           (pair.first.size() * sizeof(Char)) +
+                                           pair.second.estimated_byte_size();
+                                  });
   } else if (this->is_array()) {
-    return std::accumulate(
-        this->as_array().cbegin(), this->as_array().cend(),
-        static_cast<std::uint64_t>(0),
+    return std::ranges::fold_left(
+        this->as_array(), static_cast<std::uint64_t>(0),
         [](const std::uint64_t accumulator, const JSON &item) {
           return accumulator + item.estimated_byte_size();
         });
@@ -499,21 +496,19 @@ auto JSON::operator-=(const JSON &substractive) -> JSON & {
     case Type::String:
       return 3 + this->byte_size();
     case Type::Array:
-      return std::accumulate(
-          this->as_array().cbegin(), this->as_array().cend(),
-          static_cast<std::uint64_t>(6),
+      return std::ranges::fold_left(
+          this->as_array(), static_cast<std::uint64_t>(6),
           [](const std::uint64_t accumulator, const JSON &item) {
             return accumulator + 1 + item.fast_hash();
           });
     case Type::Object:
-      return std::accumulate(this->as_object().cbegin(),
-                             this->as_object().cend(),
-                             static_cast<std::uint64_t>(7),
-                             [](const std::uint64_t accumulator,
-                                const typename Object::value_type &pair) {
-                               return accumulator + 1 + pair.first.size() +
-                                      pair.second.fast_hash();
-                             });
+      return std::ranges::fold_left(
+          this->as_object(), static_cast<std::uint64_t>(7),
+          [](const std::uint64_t accumulator,
+             const typename Object::value_type &pair) {
+            return accumulator + 1 + pair.first.size() +
+                   pair.second.fast_hash();
+          });
     case Type::Decimal:
       return 8;
     default:
@@ -582,8 +577,7 @@ JSON::defines_any(std::initializer_list<JSON::String> keys) const -> bool {
 
 [[nodiscard]] auto JSON::contains(const JSON &element) const -> bool {
   assert(this->is_array());
-  return std::find(this->as_array().cbegin(), this->as_array().cend(),
-                   element) != this->as_array().cend();
+  return std::ranges::contains(this->as_array(), element);
 }
 
 [[nodiscard]] auto JSON::contains(const JSON::StringView element) const
@@ -600,13 +594,13 @@ JSON::defines_any(std::initializer_list<JSON::String> keys) const -> bool {
 
 [[nodiscard]] auto JSON::includes(const JSON::String &input) const -> bool {
   assert(this->is_string());
-  return this->to_string().find(input) != JSON::String::npos;
+  return this->to_string().contains(input);
 }
 
 [[nodiscard]] auto JSON::includes(const JSON::String::value_type input) const
     -> bool {
   assert(this->is_string());
-  return this->to_string().find(input) != JSON::String::npos;
+  return this->to_string().contains(input);
 }
 
 [[nodiscard]] auto JSON::unique() const -> bool {
@@ -653,12 +647,11 @@ auto JSON::push_back_if_unique(const JSON &value)
     -> std::pair<std::reference_wrapper<const JSON>, bool> {
   assert(this->is_array());
   auto &array_data{this->as_array().data};
-  const auto match{std::ranges::find(array_data, value)};
-  if (match == array_data.cend()) {
+  if (!std::ranges::contains(array_data, value)) {
     array_data.push_back(value);
     return {array_data.back(), true};
   } else {
-    return {*match, false};
+    return {*std::ranges::find(array_data, value), false};
   }
 }
 
@@ -666,12 +659,11 @@ auto JSON::push_back_if_unique(JSON &&value)
     -> std::pair<std::reference_wrapper<const JSON>, bool> {
   assert(this->is_array());
   auto &array_data{this->as_array().data};
-  const auto match{std::ranges::find(array_data, value)};
-  if (match == array_data.cend()) {
+  if (!std::ranges::contains(array_data, value)) {
     array_data.push_back(std::move(value));
     return {array_data.back(), true};
   } else {
-    return {*match, false};
+    return {*std::ranges::find(array_data, value), false};
   }
 }
 
diff --git a/vendor/core/src/core/json/parser.h b/vendor/core/src/core/json/parser.h
index 5dae84137..b5f8eed1e 100644
--- a/vendor/core/src/core/json/parser.h
+++ b/vendor/core/src/core/json/parser.h
@@ -73,10 +73,10 @@ inline auto scan_null(const std::uint64_t line, std::uint64_t &column,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
-    if (*cursor != character) {
+    if (*cursor != character) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     cursor++;
@@ -93,10 +93,10 @@ inline auto scan_true(const std::uint64_t line, std::uint64_t &column,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
-    if (*cursor != character) {
+    if (*cursor != character) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     cursor++;
@@ -113,10 +113,10 @@ inline auto scan_false(const std::uint64_t line, std::uint64_t &column,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
-    if (*cursor != character) {
+    if (*cursor != character) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     cursor++;
@@ -133,7 +133,7 @@ inline auto scan_string_unicode_code_point(const std::uint64_t line,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     const char hex_char{*cursor++};
@@ -144,7 +144,7 @@ inline auto scan_string_unicode_code_point(const std::uint64_t line,
       digit = static_cast<unsigned long>(hex_char - 'a') + 10;
     } else if (hex_char >= 'A' && hex_char <= 'F') {
       digit = static_cast<unsigned long>(hex_char - 'A') + 10;
-    } else {
+    } else [[unlikely]] {
       throw JSONParseError(line, column);
     }
     result = (result << 4) | digit;
@@ -161,7 +161,7 @@ inline auto scan_string_unicode(const std::uint64_t line, std::uint64_t &column,
                                                                  cursor, end)};
   using CharT = typename JSON::Char;
 
-  if (code_point >= 0xDC00 && code_point <= 0xDFFF) {
+  if (code_point >= 0xDC00 && code_point <= 0xDFFF) [[unlikely]] {
     throw JSONParseError(line, column);
   }
 
@@ -169,10 +169,10 @@ inline auto scan_string_unicode(const std::uint64_t line, std::uint64_t &column,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
-    if (*cursor != internal::token_string_escape<CharT>) {
+    if (*cursor != internal::token_string_escape<CharT>) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     cursor++;
@@ -180,10 +180,10 @@ inline auto scan_string_unicode(const std::uint64_t line, std::uint64_t &column,
     if constexpr (TrackPositions) {
       column += 1;
     }
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       throw JSONParseError(line, column);
     }
-    if (*cursor != internal::token_string_escape_unicode<CharT>) {
+    if (*cursor != internal::token_string_escape_unicode<CharT>) [[unlikely]] {
       throw JSONParseError(line, column);
     }
     cursor++;
@@ -193,7 +193,7 @@ inline auto scan_string_unicode(const std::uint64_t line, std::uint64_t &column,
 
     // See
     // https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF
-    if (low_code_point < 0xDC00 || low_code_point > 0xDFFF) {
+    if (low_code_point < 0xDC00 || low_code_point > 0xDFFF) [[unlikely]] {
       throw JSONParseError(line, column);
     }
   }
@@ -205,7 +205,7 @@ inline auto scan_string_escape(const std::uint64_t line, std::uint64_t &column,
   if constexpr (TrackPositions) {
     column += 1;
   }
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     throw JSONParseError(line, column);
   }
   switch (*cursor++) {
@@ -222,7 +222,7 @@ inline auto scan_string_escape(const std::uint64_t line, std::uint64_t &column,
       scan_string_unicode<TrackPositions>(line, column, cursor, end);
       return;
     default:
-      throw JSONParseError(line, column);
+      [[unlikely]] throw JSONParseError(line, column);
   }
 }
 
@@ -245,7 +245,7 @@ inline auto scan_string(const std::uint64_t line, std::uint64_t &column,
       cursor = scan;
     }
 
-    if (cursor >= end) {
+    if (cursor >= end) [[unlikely]] {
       if constexpr (TrackPositions) {
         column += 1;
       }
@@ -264,7 +264,7 @@ inline auto scan_string(const std::uint64_t line, std::uint64_t &column,
         scan_string_escape<TrackPositions>(line, column, cursor, end);
         break;
       default:
-        throw JSONParseError(line, column);
+        [[unlikely]] throw JSONParseError(line, column);
     }
   }
 
@@ -288,7 +288,7 @@ inline auto scan_digits(const std::uint64_t line, std::uint64_t &column,
     }
     cursor++;
   }
-  if (at_least_one && !found) {
+  if (at_least_one && !found) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -303,7 +303,7 @@ inline auto scan_number(const std::uint64_t line, std::uint64_t &column,
   using CharT = typename JSON::Char;
   if (first == internal::token_number_minus<CharT>) {
     if (cursor >= end || *cursor < internal::token_number_zero<CharT> ||
-        *cursor > internal::token_number_nine<CharT>) {
+        *cursor > internal::token_number_nine<CharT>) [[unlikely]] {
       if constexpr (TrackPositions) {
         column += 1;
       }
@@ -322,7 +322,7 @@ inline auto scan_number(const std::uint64_t line, std::uint64_t &column,
 
   if (int_start == internal::token_number_zero<CharT>) {
     if (cursor < end && *cursor >= internal::token_number_zero<CharT> &&
-        *cursor <= internal::token_number_nine<CharT>) {
+        *cursor <= internal::token_number_nine<CharT>) [[unlikely]] {
       if constexpr (TrackPositions) {
         column += 1;
       }
@@ -378,7 +378,7 @@ inline auto scan_json(const char *&cursor, const char *end,
   container_stack.reserve(32);
 
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -441,7 +441,7 @@ inline auto scan_json(const char *&cursor, const char *end,
         return;
       }
       default:
-        throw JSONParseError(line, column);
+        [[unlikely]] throw JSONParseError(line, column);
     }
   }
 
@@ -455,7 +455,7 @@ do_scan_array: {
   container_stack.push_back({start_index, 0});
 
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -481,7 +481,7 @@ do_scan_array: {
   container_stack.back().child_count++;
 
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -544,13 +544,13 @@ do_scan_array: {
         goto do_scan_array_item_separator;
       }
       default:
-        throw JSONParseError(line, column);
+        [[unlikely]] throw JSONParseError(line, column);
     }
   }
 
 do_scan_array_item_separator:
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -572,7 +572,7 @@ do_scan_array: {
       goto do_scan_container_end;
     }
     default:
-      throw JSONParseError(line, column);
+      [[unlikely]] throw JSONParseError(line, column);
   }
 
   /*
@@ -585,7 +585,7 @@ do_scan_object: {
   container_stack.push_back({start_index, 0});
 
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -611,7 +611,7 @@ do_scan_object: {
   container_stack.back().child_count++;
 
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -634,12 +634,12 @@ do_scan_object: {
       goto do_scan_object_separator;
     }
     default:
-      throw JSONParseError(line, column);
+      [[unlikely]] throw JSONParseError(line, column);
   }
 
 do_scan_object_separator:
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -653,12 +653,12 @@ do_scan_object: {
     case internal::token_object_key_delimiter<CharT>:
       goto do_scan_object_value;
     default:
-      throw JSONParseError(line, column);
+      [[unlikely]] throw JSONParseError(line, column);
   }
 
 do_scan_object_value:
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -721,13 +721,13 @@ do_scan_object: {
         goto do_scan_object_property_end;
       }
       default:
-        throw JSONParseError(line, column);
+        [[unlikely]] throw JSONParseError(line, column);
     }
   }
 
 do_scan_object_property_end:
   internal::skip_whitespace<TrackPositions>(cursor, end, line, column);
-  if (cursor >= end) {
+  if (cursor >= end) [[unlikely]] {
     if constexpr (TrackPositions) {
       column += 1;
     }
@@ -749,7 +749,7 @@ do_scan_object: {
       goto do_scan_container_end;
     }
     default:
-      throw JSONParseError(line, column);
+      [[unlikely]] throw JSONParseError(line, column);
   }
 
 do_scan_container_end:
diff --git a/vendor/core/src/core/json/stringify.h b/vendor/core/src/core/json/stringify.h
index 77c91a2eb..c32dcca28 100644
--- a/vendor/core/src/core/json/stringify.h
+++ b/vendor/core/src/core/json/stringify.h
@@ -16,7 +16,7 @@
 #include <iterator>  // std::next, std::cbegin, std::cend, std::back_inserter
 #include <ostream>   // std::basic_ostream
 #include <sstream>   // std::ostringstream
-#include <string>    // std::to_string
+#include <string>    // std::basic_string
 #include <vector>    // std::vector
 
 namespace sourcemeta::core::internal {
@@ -64,11 +64,13 @@ auto stringify(
     const std::int64_t value,
     std::basic_ostream<typename JSON::Char, typename JSON::CharTraits> &stream)
     -> void {
-  const auto string{std::to_string(value)};
-  stream.write(string.c_str(),
+  std::array<char, 20> buffer{};
+  const auto [end_pointer, error_code] =
+      std::to_chars(buffer.data(), buffer.data() + buffer.size(), value);
+  stream.write(buffer.data(),
                static_cast<typename std::basic_ostream<
                    typename JSON::Char, typename JSON::CharTraits>::int_type>(
-                   string.size()));
+                   end_pointer - buffer.data()));
 }
 
 template <template <typename T> typename Allocator>
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 56885d9fb..5f01faa1d 100644
--- a/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h
+++ b/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer.h
@@ -21,7 +21,6 @@
 #include <ostream>     // std::basic_ostream
 #include <string>      // std::basic_string
 #include <string_view> // std::string_view
-#include <type_traits> // std::is_same_v
 
 /// @defgroup jsonpointer JSON Pointer
 /// @brief A growing implementation of RFC 6901 JSON Pointer.
@@ -619,38 +618,6 @@ auto to_uri(const WeakPointer &pointer, const std::string_view base) -> URI;
 /// ```
 using PointerWalker = GenericPointerWalker<WeakPointer>;
 
-/// @ingroup jsonpointer
-/// Serialise a Pointer as JSON
-template <typename T>
-  requires std::is_same_v<T, Pointer>
-auto to_json(const T &value) -> JSON {
-  return JSON{to_string(value)};
-}
-
-/// @ingroup jsonpointer
-/// Serialise a WeakPointer as JSON
-template <typename T>
-  requires std::is_same_v<T, WeakPointer>
-auto to_json(const T &value) -> JSON {
-  return JSON{to_string(value)};
-}
-
-/// @ingroup jsonpointer
-/// Deserialise a Pointer from JSON
-template <typename T>
-  requires std::is_same_v<T, Pointer>
-auto from_json(const JSON &value) -> std::optional<T> {
-  if (!value.is_string()) {
-    return std::nullopt;
-  }
-
-  try {
-    return to_pointer(value);
-  } catch (const PointerParseError &) {
-    return std::nullopt;
-  }
-}
-
 } // namespace sourcemeta::core
 
 #endif
diff --git a/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer_pointer.h b/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer_pointer.h
index 3c10e703e..a07242a02 100644
--- a/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer_pointer.h
+++ b/vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer_pointer.h
@@ -3,13 +3,15 @@
 
 #include <sourcemeta/core/jsonpointer_token.h>
 
-#include <algorithm>        // std::copy, std::equal
+#include <algorithm>        // std::move, std::equal
 #include <cassert>          // assert
 #include <cstddef>          // std::size_t
 #include <functional>       // std::reference_wrapper
 #include <initializer_list> // std::initializer_list
 #include <iterator>         // std::advance, std::back_inserter
-#include <type_traits>      // std::enable_if_t, std::is_same_v, std::false_type
+#include <optional>         // std::optional
+#include <ranges>           // std::ranges::subrange
+#include <type_traits>      // std::is_same_v, std::decay_t
 #include <utility>          // std::move
 #include <vector>           // std::vector
 
@@ -23,8 +25,6 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   using Token = GenericToken<PropertyT, Hash>;
   using Value = typename Token::Value;
   using Container = std::vector<Token>;
-  // We manually provide a JSON transformer
-  using json_auto = std::false_type;
 
   /// This constructor creates an empty JSON Pointer. For example:
   ///
@@ -228,8 +228,13 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     }
 
     this->reserve(this->data.size() + other.size());
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+    this->data.append_range(other.data);
+#else
     std::copy(other.data.cbegin(), other.data.cend(),
               std::back_inserter(this->data));
+#endif
   }
 
   /// Move a JSON Pointer into the back of a JSON Pointer. For example:
@@ -465,7 +470,13 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     std::advance(new_begin, index);
     GenericPointer<PropertyT, Hash> result;
     result.reserve(this->size() - index);
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+    result.data.append_range(
+        std::ranges::subrange(new_begin, this->data.cend()));
+#else
     std::copy(new_begin, this->data.cend(), std::back_inserter(result.data));
+#endif
     return result;
   }
 
@@ -496,7 +507,12 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     std::advance(new_end, end);
     GenericPointer<PropertyT, Hash> result;
     result.reserve(end - start);
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+    result.data.append_range(std::ranges::subrange(new_begin, new_end));
+#else
     std::copy(new_begin, new_end, std::back_inserter(result.data));
+#endif
     return result;
   }
 
@@ -669,7 +685,13 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     auto new_begin{this->data.cbegin()};
     std::advance(new_begin, index);
     GenericPointer<PropertyT, Hash> result{replacement};
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+    result.data.append_range(
+        std::ranges::subrange(new_begin, this->data.cend()));
+#else
     std::copy(new_begin, this->data.cend(), std::back_inserter(result.data));
+#endif
     return result;
   }
 
@@ -710,7 +732,13 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     const auto remaining{static_cast<typename Container::size_type>(
         this->data.cend() - new_begin)};
     result.data.reserve(remaining);
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+    result.data.append_range(
+        std::ranges::subrange(new_begin, this->data.cend()));
+#else
     std::copy(new_begin, this->data.cend(), std::back_inserter(result.data));
+#endif
     return result;
   }
 
@@ -817,6 +845,40 @@ template <typename PropertyT, typename Hash> class GenericPointer {
     }
   };
 
+  /// Serialise a JSON Pointer as a JSON array of tokens
+  [[nodiscard]] auto to_json() const -> Value {
+    auto result{Value::make_array()};
+    for (const auto &token : this->data) {
+      result.push_back(token.to_json());
+    }
+
+    return result;
+  }
+
+  /// Deserialise a JSON Pointer from a JSON array of tokens
+  static auto from_json(const Value &value)
+      -> std::optional<GenericPointer<PropertyT, Hash>>
+    requires std::is_same_v<PropertyT, typename Value::String>
+  {
+    if (!value.is_array()) {
+      return std::nullopt;
+    }
+
+    GenericPointer<PropertyT, Hash> result;
+    for (const auto &element : value.as_array()) {
+      if (element.is_string()) {
+        result.emplace_back(element.to_string());
+      } else if (element.is_integer()) {
+        result.emplace_back(
+            static_cast<typename Token::Index>(element.to_integer()));
+      } else {
+        return std::nullopt;
+      }
+    }
+
+    return result;
+  }
+
 private:
   Container data;
 };
diff --git a/vendor/core/src/core/jsonpointer/jsonpointer.cc b/vendor/core/src/core/jsonpointer/jsonpointer.cc
index 0b9442c61..8c7c4a3af 100644
--- a/vendor/core/src/core/jsonpointer/jsonpointer.cc
+++ b/vendor/core/src/core/jsonpointer/jsonpointer.cc
@@ -8,7 +8,9 @@
 #include "parser.h"
 #include "stringify.h"
 
+#include <array>       // std::array
 #include <cassert>     // assert
+#include <charconv>    // std::to_chars
 #include <iterator>    // std::cbegin, std::cend, std::prev, std::advance
 #include <memory>      // std::allocator
 #include <ostream>     // std::basic_ostream
@@ -56,7 +58,10 @@ auto traverse(V &document, typename PointerT::const_iterator begin,
       // token.
       // See https://www.rfc-editor.org/rfc/rfc6901#section-4
       if (current->is_object()) {
-        current = &current->at(std::to_string(iterator->to_index()));
+        std::array<char, 20> buffer{};
+        const auto [end_pointer, error_code] = std::to_chars(
+            buffer.data(), buffer.data() + buffer.size(), iterator->to_index());
+        current = &current->at(std::string{buffer.data(), end_pointer});
       } else {
         current = &current->at(iterator->to_index());
       }
@@ -83,7 +88,10 @@ auto traverse_all(V &document, const PointerT &pointer) -> V & {
       current = &current->at(token.to_property(), token.property_hash());
     } else {
       if (current->is_object()) {
-        current = &current->at(std::to_string(token.to_index()));
+        std::array<char, 20> buffer{};
+        const auto [end_pointer, error_code] = std::to_chars(
+            buffer.data(), buffer.data() + buffer.size(), token.to_index());
+        current = &current->at(std::string{buffer.data(), end_pointer});
       } else {
         current = &current->at(token.to_index());
       }
@@ -120,7 +128,10 @@ auto try_traverse(const sourcemeta::core::JSON &document,
       const auto index{token.to_index()};
       if (index < current->size()) {
         if (is_object) {
-          current = &current->at(std::to_string(index));
+          std::array<char, 20> buffer{};
+          const auto [end_pointer, error_code] = std::to_chars(
+              buffer.data(), buffer.data() + buffer.size(), index);
+          current = &current->at(std::string{buffer.data(), end_pointer});
         } else {
           current = &current->at(index);
         }
@@ -223,7 +234,10 @@ auto set(JSON &document, const Pointer &pointer, const JSON &value) -> void {
     current.at(last.to_property()).into(value);
   } else {
     if (current.is_object()) {
-      current.at(std::to_string(last.to_index())).into(value);
+      std::array<char, 20> buffer{};
+      const auto [end_pointer, error_code] = std::to_chars(
+          buffer.data(), buffer.data() + buffer.size(), last.to_index());
+      current.at(std::string{buffer.data(), end_pointer}).into(value);
     } else {
       current.at(last.to_index()).into(value);
     }
@@ -273,8 +287,12 @@ auto remove_pointer(JSON &document, const PointerT &pointer) -> bool {
     return current.erase(last.to_property()) < current_size;
   } else {
     if (current.is_object()) {
+      std::array<char, 20> buffer{};
+      const auto [end_pointer, error_code] = std::to_chars(
+          buffer.data(), buffer.data() + buffer.size(), last.to_index());
       const auto current_size{current.size()};
-      return current.erase(std::to_string(last.to_index())) < current_size;
+      return current.erase(std::string{buffer.data(), end_pointer}) <
+             current_size;
     } else {
       const auto index{last.to_index()};
       const auto &array{current.as_array()};
diff --git a/vendor/core/src/core/jsonpointer/parser.h b/vendor/core/src/core/jsonpointer/parser.h
index d0bc7f658..3977321fd 100644
--- a/vendor/core/src/core/jsonpointer/parser.h
+++ b/vendor/core/src/core/jsonpointer/parser.h
@@ -7,12 +7,13 @@
 #include <sourcemeta/core/jsonpointer.h>
 #include <sourcemeta/core/jsonpointer_error.h>
 
-#include <cstdint>     // std::uint64_t
-#include <istream>     // std::basic_istream
-#include <sstream>     // std::basic_stringstream
-#include <stdexcept>   // std::out_of_range
-#include <string>      // std::stoi
-#include <type_traits> // std::conditional_t
+#include <charconv>     // std::from_chars
+#include <cstdint>      // std::uint64_t
+#include <istream>      // std::basic_istream
+#include <sstream>      // std::basic_stringstream
+#include <string>       // std::string
+#include <system_error> // std::errc
+#include <type_traits>  // std::conditional_t
 
 namespace sourcemeta::core::internal {
 template <typename CharT, typename Traits,
@@ -28,12 +29,16 @@ template <typename CharT, typename Traits,
           template <typename T> typename Allocator>
 inline auto
 parse_index(std::basic_stringstream<CharT, Traits, Allocator<CharT>> &stream,
-            const std::uint64_t column) -> decltype(auto) {
-  try {
-    return std::stoul(stream.str());
-  } catch (const std::out_of_range &) {
+            const std::uint64_t column) -> unsigned long {
+  const auto input = stream.str();
+  unsigned long index_value{};
+  const auto result =
+      std::from_chars(input.data(), input.data() + input.size(), index_value);
+  if (result.ec != std::errc{}) [[unlikely]] {
     throw PointerParseError(column);
   }
+
+  return index_value;
 }
 
 } // namespace sourcemeta::core::internal
diff --git a/vendor/core/src/core/jsonpointer/stringify.h b/vendor/core/src/core/jsonpointer/stringify.h
index 80ca67e76..d14cb93a5 100644
--- a/vendor/core/src/core/jsonpointer/stringify.h
+++ b/vendor/core/src/core/jsonpointer/stringify.h
@@ -6,12 +6,14 @@
 
 #include "grammar.h"
 
-#include <cassert> // assert
-#include <ios>     // std::basic_ostream
-#include <ostream> // std::basic_ostream
-#include <sstream> // std::basic_istringstream
-#include <string>  // std::to_string, std::basic_string
-#include <variant> // std::holds_alternative
+#include <array>    // std::array
+#include <cassert>  // assert
+#include <charconv> // std::to_chars
+#include <ios>      // std::basic_ostream
+#include <ostream>  // std::basic_ostream
+#include <sstream>  // std::basic_istringstream
+#include <string>   // std::basic_string
+#include <variant>  // std::holds_alternative
 
 namespace sourcemeta::core::internal {
 inline auto
@@ -369,11 +371,13 @@ auto stringify_token(const TokenT &token,
       }
     }
   } else {
-    const auto index{std::to_string(token.to_index())};
+    std::array<char, 20> buffer{};
+    const auto [end_pointer, error_code] = std::to_chars(
+        buffer.data(), buffer.data() + buffer.size(), token.to_index());
     stream.write(
-        index.c_str(),
+        buffer.data(),
         static_cast<typename std::basic_ostream<CharT, Traits>::int_type>(
-            index.size()));
+            end_pointer - buffer.data()));
   }
 }
 
diff --git a/vendor/core/src/core/jsonschema/bundle.cc b/vendor/core/src/core/jsonschema/bundle.cc
index b0ed8dfc0..2a1361042 100644
--- a/vendor/core/src/core/jsonschema/bundle.cc
+++ b/vendor/core/src/core/jsonschema/bundle.cc
@@ -4,7 +4,7 @@
 
 #include <cassert>       // assert
 #include <functional>    // std::reference_wrapper
-#include <sstream>       // std::ostringstream
+#include <string>        // std::string
 #include <tuple>         // std::tuple
 #include <unordered_map> // std::unordered_map
 #include <unordered_set> // std::unordered_set
@@ -123,14 +123,13 @@ auto embed_schema(sourcemeta::core::JSON &root,
         "Could not bundle to a container path that is not an object");
   }
 
-  std::ostringstream key;
-  key << identifier;
+  std::string key{identifier};
   // Ensure we get a definitions entry that does not exist
-  while (current->defines(key.str())) {
-    key << "/x";
+  while (current->defines(key)) {
+    key += "/x";
   }
 
-  current->assign(key.str(), std::move(target));
+  current->assign(key, std::move(target));
 }
 
 auto elevate_embedded_resources(
@@ -171,8 +170,7 @@ auto elevate_embedded_resources(
     const auto &value{entry.second};
     const auto entry_dialect{
         sourcemeta::core::base_dialect(value, resolver, default_dialect)};
-    const auto effective_entry_dialect{
-        entry_dialect.has_value() ? entry_dialect.value() : remote_dialect};
+    const auto effective_entry_dialect{entry_dialect.value_or(remote_dialect)};
     const auto identifier{
         sourcemeta::core::identify(value, effective_entry_dialect)};
     if (identifier.empty() || identifier != key ||
@@ -413,7 +411,7 @@ auto bundle(JSON &schema, const SchemaWalker &walker,
   SchemaFrame initial_frame{SchemaFrame::Mode::Locations};
   initial_frame.analyse(schema, walker, resolver, default_dialect, default_id,
                         paths);
-  initial_frame.for_each_resource_uri([&bundled](const auto uri) {
+  initial_frame.for_each_resource_uri([&bundled](const auto &uri) {
     bundled.emplace(JSON::String{uri}, JSON::String{uri});
   });
   if (default_container.has_value()) {
diff --git a/vendor/core/src/core/jsonschema/frame.cc b/vendor/core/src/core/jsonschema/frame.cc
index 0770b2511..f6f18b8d5 100644
--- a/vendor/core/src/core/jsonschema/frame.cc
+++ b/vendor/core/src/core/jsonschema/frame.cc
@@ -2,7 +2,7 @@
 
 #include "helpers.h"
 
-#include <algorithm>     // std::sort, std::all_of, std::any_of
+#include <algorithm> // std::ranges::all_of, std::ranges::contains, std::ranges::sort
 #include <cassert>       // assert
 #include <functional>    // std::less
 #include <map>           // std::map
@@ -105,11 +105,10 @@ auto find_anchors(const sourcemeta::core::JSON &schema,
            sourcemeta::core::Vocabularies::Known::JSON_Schema_Draft_6))) {
     if (schema.defines("$id")) {
       assert(schema.at("$id").is_string());
-      const auto &id_string{schema.at("$id").to_string()};
-      if (id_string.starts_with('#')) {
+      const std::string_view id_view{schema.at("$id").to_string()};
+      if (id_view.starts_with('#')) {
         // The original string is "#fragment", skip the '#'
-        result.emplace_back(std::string_view{id_string}.substr(1),
-                            AnchorType::Static);
+        result.emplace_back(id_view.substr(1), AnchorType::Static);
       }
     }
   }
@@ -121,11 +120,10 @@ auto find_anchors(const sourcemeta::core::JSON &schema,
           sourcemeta::core::Vocabularies::Known::JSON_Schema_Draft_4)) {
     if (schema.defines("id")) {
       assert(schema.at("id").is_string());
-      const auto &id_string{schema.at("id").to_string()};
-      if (id_string.starts_with('#')) {
+      const std::string_view id_view{schema.at("id").to_string()};
+      if (id_view.starts_with('#')) {
         // The original string is "#fragment", skip the '#'
-        result.emplace_back(std::string_view{id_string}.substr(1),
-                            AnchorType::Static);
+        result.emplace_back(id_view.substr(1), AnchorType::Static);
       }
     }
   }
@@ -242,26 +240,26 @@ auto supports_id_anchors(const sourcemeta::core::SchemaBaseDialect base_dialect)
 
 auto set_base_and_fragment(
     sourcemeta::core::SchemaFrame::ReferencesEntry &entry) -> void {
-  if (entry.destination.empty()) {
+  const std::string_view destination_view{entry.destination};
+  if (destination_view.empty()) {
     entry.base = std::string_view{};
     entry.fragment = std::nullopt;
     return;
   }
 
-  const auto hash_position{entry.destination.find('#')};
+  const auto hash_position{destination_view.find('#')};
   if (hash_position != std::string::npos) {
     // Has a fragment
     if (hash_position == 0) {
       // Starts with #, so no base
       entry.base = std::string_view{};
     } else {
-      entry.base = std::string_view{entry.destination}.substr(0, hash_position);
+      entry.base = destination_view.substr(0, hash_position);
     }
-    entry.fragment =
-        std::string_view{entry.destination}.substr(hash_position + 1);
+    entry.fragment = destination_view.substr(hash_position + 1);
   } else {
     // No fragment
-    entry.base = std::string_view{entry.destination};
+    entry.base = destination_view;
     entry.fragment = std::nullopt;
   }
 }
@@ -627,9 +625,7 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
 
             auto base_uri_match{base_uris.find(common_pointer_weak)};
             if (base_uri_match != base_uris.cend()) {
-              if (std::find(base_uri_match->second.cbegin(),
-                            base_uri_match->second.cend(),
-                            new_id) == base_uri_match->second.cend()) {
+              if (!std::ranges::contains(base_uri_match->second, new_id)) {
                 base_uri_match->second.push_back(new_id);
               }
             } else {
@@ -1272,25 +1268,6 @@ auto SchemaFrame::dereference(const Location &location,
   return {SchemaReferenceType::Static, destination->second};
 }
 
-auto SchemaFrame::for_each_resource_uri(
-    const std::function<void(std::string_view)> &callback) const -> void {
-  for (const auto &[key, location] : this->locations_) {
-    if (location.type == LocationType::Resource) {
-      callback(key.second);
-    }
-  }
-}
-
-auto SchemaFrame::for_each_unresolved_reference(
-    const std::function<void(const WeakPointer &, const ReferencesEntry &)>
-        &callback) const -> void {
-  for (const auto &[key, reference] : this->references_) {
-    if (!this->traverse(reference.destination).has_value()) {
-      callback(key.second, reference);
-    }
-  }
-}
-
 auto SchemaFrame::has_references_to(const WeakPointer &pointer) const -> bool {
   for (const auto &reference : this->references_) {
     assert(!reference.first.second.empty());
diff --git a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema.h b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema.h
index 4e44ce623..1f2fbd847 100644
--- a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema.h
+++ b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema.h
@@ -317,6 +317,45 @@ auto base_dialect(const JSON &schema, const SchemaResolver &resolver,
                   std::string_view default_dialect = "")
     -> std::optional<SchemaBaseDialect>;
 
+/// @ingroup jsonschema
+///
+/// Parse the `$vocabulary` keyword from a given schema, if set. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/json.h>
+/// #include <sourcemeta/core/jsonschema.h>
+/// #include <cassert>
+///
+/// const sourcemeta::core::JSON document =
+///   sourcemeta::core::parse_json(R"JSON({
+///   "$schema": "https://json-schema.org/draft/2020-12/schema",
+///   "$vocabulary": {
+///     "https://json-schema.org/draft/2020-12/vocab/core": true,
+///     "https://json-schema.org/draft/2020-12/vocab/applicator": true
+///   }
+/// })JSON");
+///
+/// const auto result{
+///   sourcemeta::core::parse_vocabularies(
+///     document, sourcemeta::core::schema_resolver)};
+///
+/// assert(result.has_value());
+/// assert(result->size() == 2);
+/// ```
+SOURCEMETA_CORE_JSONSCHEMA_EXPORT
+auto parse_vocabularies(const JSON &schema, const SchemaResolver &resolver,
+                        std::string_view default_dialect = "")
+    -> std::optional<Vocabularies>;
+
+/// @ingroup jsonschema
+///
+/// A shortcut to sourcemeta::core::parse_vocabularies when the base dialect
+/// is already known.
+SOURCEMETA_CORE_JSONSCHEMA_EXPORT
+auto parse_vocabularies(const JSON &schema,
+                        const SchemaBaseDialect base_dialect)
+    -> std::optional<Vocabularies>;
+
 /// @ingroup jsonschema
 ///
 /// List the vocabularies that a specific schema makes use of. If you set a
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 74ec0370a..cbc85e378 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
@@ -11,6 +11,7 @@
 #include <sourcemeta/core/jsonschema_types.h>
 #include <sourcemeta/core/jsonschema_walker.h>
 
+#include <concepts>      // std::invocable
 #include <cstdint>       // std::uint8_t
 #include <functional>    // std::reference_wrapper
 #include <map>           // std::map
@@ -127,6 +128,8 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
   /// A JSON Schema reference frame is a mapping of URIs to schema identifiers,
   /// JSON Pointers within the schema, and subschemas dialects. We call it
   /// reference frame as this mapping is essential for resolving references.
+  // TODO: Consider replacing std::map with std::flat_map once libc++
+  // supports it (__cpp_lib_flat_map) for better cache locality
   using Locations =
       // While it might seem weird that we namespace the location URIs with a
       // reference type, it is essential for distinguishing schema resource URIs
@@ -209,14 +212,25 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
                    std::optional<std::reference_wrapper<const Location>>>;
 
   /// Iterate over all resource URIs in the frame
-  auto for_each_resource_uri(
-      const std::function<void(std::string_view)> &callback) const -> void;
+  template <std::invocable<std::string_view> F>
+  auto for_each_resource_uri(const F &callback) const -> void {
+    for (const auto &[key, location] : this->locations_) {
+      if (location.type == LocationType::Resource) {
+        callback(key.second);
+      }
+    }
+  }
 
   /// Iterate over all unresolved references (where destination cannot be
   /// traversed)
-  auto for_each_unresolved_reference(
-      const std::function<void(const WeakPointer &, const ReferencesEntry &)>
-          &callback) const -> void;
+  template <std::invocable<const WeakPointer &, const ReferencesEntry &> F>
+  auto for_each_unresolved_reference(const F &callback) const -> void {
+    for (const auto &[key, reference] : this->references_) {
+      if (!this->traverse(reference.destination).has_value()) {
+        callback(key.second, reference);
+      }
+    }
+  }
 
   /// Check if there are any references to a given location pointer
   [[nodiscard]] auto has_references_to(const WeakPointer &pointer) const
diff --git a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h
index cf48954c7..af3e4b5af 100644
--- a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h
+++ b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h
@@ -98,8 +98,13 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaTransformRule {
         locations.reserve(input.size());
       }
 
+// TODO: Remove once GitHub Actions ship proper C++23 support
+#if __cpp_lib_containers_ranges >= 202202L
+      locations.assign_range(input);
+#else
       locations.assign(std::make_move_iterator(std::begin(input)),
                        std::make_move_iterator(std::end(input)));
+#endif
     }
 
     Result(std::vector<Pointer> &&locations_, JSON::String &&description_)
diff --git a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_vocabularies.h b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_vocabularies.h
index 9333bd65d..345d1213f 100644
--- a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_vocabularies.h
+++ b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_vocabularies.h
@@ -7,11 +7,13 @@
 
 #include <sourcemeta/core/json.h>
 
-#include <bitset>        // std::bitset
-#include <cassert>       // assert
-#include <cstdint>       // std::uint32_t, std::size_t
+#include <bitset>  // std::bitset
+#include <cassert> // assert
+#include <cstdint> // std::uint32_t, std::size_t
+#include <format> // std::formatter, std::format_context, std::format_parse_context, std::format_to
 #include <optional>      // std::optional
 #include <ostream>       // std::ostream
+#include <sstream>       // std::ostringstream
 #include <stdexcept>     // std::out_of_range
 #include <string_view>   // std::string_view
 #include <unordered_map> // std::unordered_map
@@ -165,4 +167,32 @@ to_string(const Vocabularies::URI &vocabulary) -> std::string_view;
 
 } // namespace sourcemeta::core
 
+template <> struct std::formatter<sourcemeta::core::Vocabularies::Known> {
+  constexpr auto parse(std::format_parse_context &context)
+      -> decltype(context.begin()) {
+    return context.begin();
+  }
+
+  auto format(const sourcemeta::core::Vocabularies::Known value,
+              std::format_context &context) const -> decltype(context.out()) {
+    std::ostringstream stream;
+    stream << value;
+    return std::format_to(context.out(), "{}", stream.str());
+  }
+};
+
+template <> struct std::formatter<sourcemeta::core::Vocabularies::URI> {
+  constexpr auto parse(std::format_parse_context &context)
+      -> decltype(context.begin()) {
+    return context.begin();
+  }
+
+  auto format(const sourcemeta::core::Vocabularies::URI &value,
+              std::format_context &context) const -> decltype(context.out()) {
+    std::ostringstream stream;
+    stream << value;
+    return std::format_to(context.out(), "{}", stream.str());
+  }
+};
+
 #endif
diff --git a/vendor/core/src/core/jsonschema/jsonschema.cc b/vendor/core/src/core/jsonschema/jsonschema.cc
index f7071696d..e2b300629 100644
--- a/vendor/core/src/core/jsonschema/jsonschema.cc
+++ b/vendor/core/src/core/jsonschema/jsonschema.cc
@@ -2,16 +2,16 @@
 
 #include "helpers.h"
 
+#include <algorithm>     // std::max, std::ranges::fold_left
 #include <cassert>       // assert
 #include <cstdint>       // std::uint64_t
 #include <limits>        // std::numeric_limits
-#include <numeric>       // std::accumulate
 #include <sstream>       // std::ostringstream
 #include <string_view>   // std::string_view
 #include <type_traits>   // std::remove_reference_t
 #include <unordered_map> // std::unordered_map
 #include <unordered_set> // std::unordered_set
-#include <utility>       // std::move
+#include <utility>       // std::move, std::to_underlying
 
 auto sourcemeta::core::is_schema(const sourcemeta::core::JSON &schema) -> bool {
   return schema.is_object() || schema.is_boolean();
@@ -440,6 +440,55 @@ auto is_pre_vocabulary_base_dialect(
 }
 } // namespace
 
+auto sourcemeta::core::parse_vocabularies(
+    const sourcemeta::core::JSON &schema,
+    const sourcemeta::core::SchemaBaseDialect base_dialect)
+    -> std::optional<sourcemeta::core::Vocabularies> {
+  if (base_dialect !=
+          sourcemeta::core::SchemaBaseDialect::JSON_Schema_2020_12 &&
+      base_dialect !=
+          sourcemeta::core::SchemaBaseDialect::JSON_Schema_2020_12_Hyper &&
+      base_dialect !=
+          sourcemeta::core::SchemaBaseDialect::JSON_Schema_2019_09 &&
+      base_dialect !=
+          sourcemeta::core::SchemaBaseDialect::JSON_Schema_2019_09_Hyper) {
+    return std::nullopt;
+  }
+
+  if (!schema.is_object()) {
+    return std::nullopt;
+  }
+
+  const auto *vocabulary_entry{schema.try_at("$vocabulary")};
+  if (!vocabulary_entry) {
+    return std::nullopt;
+  }
+
+  assert(vocabulary_entry->is_object());
+  sourcemeta::core::Vocabularies result;
+  for (const auto &entry : vocabulary_entry->as_object()) {
+    assert(entry.second.is_boolean());
+    result.insert(entry.first, entry.second.to_boolean());
+  }
+
+  return result;
+}
+
+auto sourcemeta::core::parse_vocabularies(
+    const sourcemeta::core::JSON &schema,
+    const sourcemeta::core::SchemaResolver &resolver,
+    std::string_view default_dialect)
+    -> std::optional<sourcemeta::core::Vocabularies> {
+  const auto schema_base_dialect{
+      sourcemeta::core::base_dialect(schema, resolver, default_dialect)};
+  if (schema_base_dialect.has_value()) {
+    return sourcemeta::core::parse_vocabularies(schema,
+                                                schema_base_dialect.value());
+  } else {
+    return std::nullopt;
+  }
+}
+
 auto sourcemeta::core::vocabularies(
     const sourcemeta::core::JSON &schema,
     const sourcemeta::core::SchemaResolver &resolver,
@@ -545,16 +594,10 @@ auto sourcemeta::core::vocabularies(const SchemaResolver &resolver,
    * dialect
    */
 
-  Vocabularies result;
   const auto core{core_vocabulary_known(base_dialect)};
-  if (schema_dialect.defines("$vocabulary")) {
-    const sourcemeta::core::JSON &vocabularies{
-        schema_dialect.at("$vocabulary")};
-    assert(vocabularies.is_object());
-    for (const auto &entry : vocabularies.as_object()) {
-      result.insert(entry.first, entry.second.to_boolean());
-    }
-  } else {
+  auto result{parse_vocabularies(schema_dialect, base_dialect)
+                  .value_or(Vocabularies{})};
+  if (result.empty()) {
     result.insert(core, true);
   }
 
@@ -578,17 +621,15 @@ auto sourcemeta::core::schema_keyword_priority(
     const sourcemeta::core::Vocabularies &vocabularies,
     const sourcemeta::core::SchemaWalker &walker) -> std::uint64_t {
   const auto &result{walker(keyword, vocabularies)};
-  const auto priority_from_dependencies{std::accumulate(
-      result.dependencies.cbegin(), result.dependencies.cend(),
-      static_cast<std::uint64_t>(0),
+  const auto priority_from_dependencies{std::ranges::fold_left(
+      result.dependencies, static_cast<std::uint64_t>(0),
       [&vocabularies, &walker](const auto accumulator, const auto &dependency) {
         return std::max(
             accumulator,
             schema_keyword_priority(dependency, vocabularies, walker) + 1);
       })};
-  const auto priority_from_order_dependencies{std::accumulate(
-      result.order_dependencies.cbegin(), result.order_dependencies.cend(),
-      static_cast<std::uint64_t>(0),
+  const auto priority_from_order_dependencies{std::ranges::fold_left(
+      result.order_dependencies, static_cast<std::uint64_t>(0),
       [&vocabularies, &walker](const auto accumulator, const auto &dependency) {
         return std::max(
             accumulator,
@@ -703,20 +744,20 @@ static auto parse_schema_type_string(const sourcemeta::core::JSON::String &type,
                                      sourcemeta::core::JSON::TypeSet &result)
     -> void {
   if (type == "null") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Null));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Null));
   } else if (type == "boolean") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Boolean));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Boolean));
   } else if (type == "object") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Object));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Object));
   } else if (type == "array") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Array));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Array));
   } else if (type == "number") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Integer));
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Real));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Integer));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Real));
   } else if (type == "integer") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::Integer));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::Integer));
   } else if (type == "string") {
-    result.set(static_cast<std::size_t>(sourcemeta::core::JSON::Type::String));
+    result.set(std::to_underlying(sourcemeta::core::JSON::Type::String));
   }
 }
 
diff --git a/vendor/core/src/core/jsonschema/vocabularies.cc b/vendor/core/src/core/jsonschema/vocabularies.cc
index 1759ecb7d..bd3ba45cc 100644
--- a/vendor/core/src/core/jsonschema/vocabularies.cc
+++ b/vendor/core/src/core/jsonschema/vocabularies.cc
@@ -6,7 +6,7 @@
 #include <optional> // std::optional
 #include <sstream>  // std::ostringstream
 #include <string>   // std::string
-#include <utility>  // std::pair
+#include <utility>  // std::pair, std::to_underlying
 #include <vector>   // std::vector
 
 // X-macro defining all known vocabulary mappings (enum, URI)
@@ -106,8 +106,7 @@ sourcemeta::core::Vocabularies::Vocabularies(
 auto sourcemeta::core::Vocabularies::contains(
     const JSON::String &uri) const noexcept -> bool {
   if (this->unknown.has_value()) {
-    const auto iterator{this->unknown->find(uri)};
-    if (iterator != this->unknown->end()) {
+    if (this->unknown->contains(uri)) {
       return true;
     }
   }
@@ -126,7 +125,7 @@ auto sourcemeta::core::Vocabularies::contains(
 
 auto sourcemeta::core::Vocabularies::contains(Known vocabulary) const noexcept
     -> bool {
-  const auto index = static_cast<std::size_t>(vocabulary);
+  const auto index = std::to_underlying(vocabulary);
   // Use [] operator instead of test() to avoid exceptions in noexcept function
   return this->required_known[index] || this->optional_known[index];
 }
@@ -159,7 +158,7 @@ auto sourcemeta::core::Vocabularies::insert(const JSON::String &uri,
 
 auto sourcemeta::core::Vocabularies::insert(Known vocabulary,
                                             bool required) noexcept -> void {
-  const auto index = static_cast<std::size_t>(vocabulary);
+  const auto index = std::to_underlying(vocabulary);
   if (required) {
     this->required_known[index] = true;
     this->optional_known[index] = false;
@@ -194,7 +193,7 @@ auto sourcemeta::core::Vocabularies::get(const JSON::String &uri) const noexcept
 
 auto sourcemeta::core::Vocabularies::get(Known vocabulary) const noexcept
     -> std::optional<bool> {
-  const auto index = static_cast<std::size_t>(vocabulary);
+  const auto index = std::to_underlying(vocabulary);
   // Use [] operator instead of test() to avoid exceptions in noexcept function
   assert(!this->required_known[index] || !this->optional_known[index]);
   if (this->required_known[index]) {
diff --git a/vendor/core/src/core/jsonschema/walker.cc b/vendor/core/src/core/jsonschema/walker.cc
index c5711c8e6..ec1c8f6b9 100644
--- a/vendor/core/src/core/jsonschema/walker.cc
+++ b/vendor/core/src/core/jsonschema/walker.cc
@@ -409,6 +409,8 @@ sourcemeta::core::SchemaKeywordIterator::SchemaKeywordIterator(
                                            resolved_dialect)
           : Vocabularies{}};
 
+  // TODO: Use std::ranges::to<std::vector>() once libc++ supports it
+  // (__cpp_lib_ranges_to_container)
   for (const auto &entry : schema.as_object()) {
     sourcemeta::core::WeakPointer entry_pointer;
     entry_pointer.push_back(std::cref(entry.first));
diff --git a/vendor/core/src/core/regex/preprocess.h b/vendor/core/src/core/regex/preprocess.h
index b844aa2cf..682aac0a9 100644
--- a/vendor/core/src/core/regex/preprocess.h
+++ b/vendor/core/src/core/regex/preprocess.h
@@ -99,37 +99,81 @@ inline auto parse_hex_digits(const std::string &content, std::size_t start,
   return value;
 }
 
-inline auto set_range(std::bitset<128> &bits, int from, int to) -> void {
-  for (int code = from; code <= to; ++code) {
-    bits.set(static_cast<std::size_t>(code));
+constexpr auto make_digit_class() -> std::bitset<128> {
+  std::bitset<128> result;
+  for (int code = '0'; code <= '9'; ++code) {
+    result.set(static_cast<std::size_t>(code));
   }
+
+  return result;
 }
 
-inline auto set_shorthand_class(std::bitset<128> &characters,
-                                const char shorthand) -> void {
-  std::bitset<128> base;
-  const char lower = static_cast<char>(shorthand | 32);
-  if (lower == 'd') {
-    set_range(base, '0', '9');
-  } else if (lower == 'w') {
-    set_range(base, 'a', 'z');
-    set_range(base, 'A', 'Z');
-    set_range(base, '0', '9');
-    base.set('_');
-  } else if (lower == 's') {
-    for (const char code : {' ', '\t', '\n', '\r', '\f', '\v'}) {
-      base.set(static_cast<std::size_t>(code));
-    }
-  } else {
-    return;
+constexpr auto make_word_class() -> std::bitset<128> {
+  std::bitset<128> result;
+  for (int code = 'a'; code <= 'z'; ++code) {
+    result.set(static_cast<std::size_t>(code));
+  }
+
+  for (int code = 'A'; code <= 'Z'; ++code) {
+    result.set(static_cast<std::size_t>(code));
   }
 
-  if (shorthand >= 'A' && shorthand <= 'Z') {
-    base.flip();
-    base.reset(0);
+  for (int code = '0'; code <= '9'; ++code) {
+    result.set(static_cast<std::size_t>(code));
   }
 
-  characters |= base;
+  result.set('_');
+  return result;
+}
+
+constexpr auto make_space_class() -> std::bitset<128> {
+  std::bitset<128> result;
+  result.set(' ');
+  result.set('\t');
+  result.set('\n');
+  result.set('\r');
+  result.set('\f');
+  result.set('\v');
+  return result;
+}
+
+constexpr auto negate_class(const std::bitset<128> &base) -> std::bitset<128> {
+  auto result = ~base;
+  result.reset(0);
+  return result;
+}
+
+constexpr auto digit_class = make_digit_class();
+constexpr auto word_class = make_word_class();
+constexpr auto space_class = make_space_class();
+constexpr auto non_digit_class = negate_class(digit_class);
+constexpr auto non_word_class = negate_class(word_class);
+constexpr auto non_space_class = negate_class(space_class);
+
+inline auto set_shorthand_class(std::bitset<128> &characters,
+                                const char shorthand) -> void {
+  switch (shorthand) {
+    case 'd':
+      characters |= digit_class;
+      return;
+    case 'D':
+      characters |= non_digit_class;
+      return;
+    case 'w':
+      characters |= word_class;
+      return;
+    case 'W':
+      characters |= non_word_class;
+      return;
+    case 's':
+      characters |= space_class;
+      return;
+    case 'S':
+      characters |= non_space_class;
+      return;
+    default:
+      return;
+  }
 }
 
 inline auto find_bracket_end(const std::string &content, std::size_t start,
@@ -214,7 +258,7 @@ inline auto parse_escape(const std::string &content, std::size_t position,
     code_point = static_cast<unsigned char>(simple_escape_values[escape_index]);
   } else if (next == '0') {
     code_point = 0;
-  } else if (shorthand_chars.find(next) != std::string_view::npos) {
+  } else if (shorthand_chars.contains(next)) {
     code_point = -1;
   } else {
     code_point = static_cast<unsigned char>(next);
@@ -281,7 +325,7 @@ inline auto parse_class_to_bitset(const std::string &content, std::size_t start,
 
   while (position < content.size() && content[position] != ']') {
     if (content[position] == '\\' && position + 1 < content.size() &&
-        shorthand_chars.find(content[position + 1]) != std::string_view::npos) {
+        shorthand_chars.contains(content[position + 1])) {
       set_shorthand_class(characters, content[position + 1]);
       position += 2;
       continue;
@@ -423,7 +467,7 @@ inline auto is_valid_escape(const std::string &content, std::size_t position)
     return (ctrl >= 'A' && ctrl <= 'Z') || (ctrl >= 'a' && ctrl <= 'z');
   }
 
-  return v_flag_syntax.find(next) != std::string_view::npos;
+  return v_flag_syntax.contains(next);
 }
 
 inline auto is_valid_operand(const std::string &operand) -> bool {
@@ -453,7 +497,7 @@ inline auto is_valid_operand(const std::string &operand) -> bool {
   }
 
   if (operand.size() == 2 && operand[0] == '\\' &&
-      shorthand_chars.find(operand[1]) != std::string_view::npos) {
+      shorthand_chars.contains(operand[1])) {
     return true;
   }
 
@@ -610,8 +654,7 @@ inline auto preprocess_regex(const std::string &pattern)
 
       // Check for v-flag operators in nested content
       const bool nested_has_ops =
-          nested_content.find("--") != std::string::npos ||
-          nested_content.find("&&") != std::string::npos;
+          nested_content.contains("--") || nested_content.contains("&&");
 
       // Check if nested content starts with a nested bracket
       // This indicates true v-flag nested class syntax like [[a-z]...]
@@ -658,7 +701,7 @@ inline auto preprocess_regex(const std::string &pattern)
     }
 
     const char next = pattern[position + 1];
-    if (std::string_view{"\\[]^$"}.find(next) != std::string_view::npos) {
+    if (std::string_view{"\\[]^$"}.contains(next)) {
       result += current;
       result += next;
       ++position;
diff --git a/vendor/core/src/core/regex/regex.cc b/vendor/core/src/core/regex/regex.cc
index 84c24ffe2..a67731d80 100644
--- a/vendor/core/src/core/regex/regex.cc
+++ b/vendor/core/src/core/regex/regex.cc
@@ -4,10 +4,13 @@
 
 #include "preprocess.h"
 
-#include <cassert> // assert
-#include <cstdint> // std::uint64_t
-#include <regex>   // std::regex, std::smatch, std::regex_match
-#include <string>  // std::string, std::stoull
+#include <cassert>      // assert
+#include <charconv>     // std::from_chars
+#include <cstdint>      // std::uint64_t
+#include <regex>        // std::regex, std::smatch, std::regex_match
+#include <string>       // std::string
+#include <system_error> // std::errc
+#include <utility>      // std::unreachable
 
 namespace sourcemeta::core {
 
@@ -33,8 +36,20 @@ auto to_regex(const std::string &pattern) -> std::optional<Regex> {
   const std::regex RANGE_REGEX{R"(^\^\.\{(\d+),(\d+)\}\$$)"};
   std::smatch matches_range;
   if (std::regex_match(pattern, matches_range, RANGE_REGEX)) {
-    const std::uint64_t minimum{std::stoull(matches_range[1].str())};
-    const std::uint64_t maximum{std::stoull(matches_range[2].str())};
+    const auto minimum_string = matches_range[1].str();
+    const auto maximum_string = matches_range[2].str();
+    std::uint64_t minimum{};
+    std::uint64_t maximum{};
+    const auto minimum_result =
+        std::from_chars(minimum_string.data(),
+                        minimum_string.data() + minimum_string.size(), minimum);
+    const auto maximum_result =
+        std::from_chars(maximum_string.data(),
+                        maximum_string.data() + maximum_string.size(), maximum);
+    if (minimum_result.ec != std::errc{} || maximum_result.ec != std::errc{}) {
+      return std::nullopt;
+    }
+
     assert(minimum <= maximum);
     return RegexTypeRange{minimum, maximum};
   }
@@ -86,11 +101,7 @@ auto matches(const Regex &regex, const std::string &value) -> bool {
       return true;
   }
 
-#if defined(_MSC_VER) && !defined(__clang__)
-  __assume(false);
-#else
-  __builtin_unreachable();
-#endif
+  std::unreachable();
 }
 
 auto matches_if_valid(const std::string &pattern, const std::string &value)
diff --git a/vendor/core/src/core/semver/semver.cc b/vendor/core/src/core/semver/semver.cc
index 7d286434c..43d335c78 100644
--- a/vendor/core/src/core/semver/semver.cc
+++ b/vendor/core/src/core/semver/semver.cc
@@ -1,8 +1,10 @@
 #include <sourcemeta/core/semver.h>
 
+#include <array>    // std::array
+#include <charconv> // std::to_chars
 #include <limits>   // std::numeric_limits
 #include <optional> // std::optional, std::nullopt
-#include <string>   // std::string, std::to_string
+#include <string>   // std::string
 
 namespace {
 
@@ -429,11 +431,21 @@ auto SemVer::operator<(const SemVer &other) const noexcept -> bool {
 }
 
 auto SemVer::to_string() const -> std::string {
-  std::string result = std::to_string(this->major_);
+  std::array<char, 20> buffer{};
+
+  auto [major_end, major_error] =
+      std::to_chars(buffer.data(), buffer.data() + buffer.size(), this->major_);
+  std::string result{buffer.data(), major_end};
   result += '.';
-  result += std::to_string(this->minor_);
+
+  auto [minor_end, minor_error] =
+      std::to_chars(buffer.data(), buffer.data() + buffer.size(), this->minor_);
+  result.append(buffer.data(), minor_end);
   result += '.';
-  result += std::to_string(this->patch_);
+
+  auto [patch_end, patch_error] =
+      std::to_chars(buffer.data(), buffer.data() + buffer.size(), this->patch_);
+  result.append(buffer.data(), patch_end);
   if (!this->pre_release_.empty()) {
     result += '-';
     result.append(this->pre_release_.data(), this->pre_release_.size());
diff --git a/vendor/core/src/core/unicode/unicode.cc b/vendor/core/src/core/unicode/unicode.cc
index 8ce8d7c6e..fa43ef100 100644
--- a/vendor/core/src/core/unicode/unicode.cc
+++ b/vendor/core/src/core/unicode/unicode.cc
@@ -107,6 +107,8 @@ auto utf8_to_utf32(std::istream &input) -> std::optional<std::u32string> {
 
 auto utf8_to_utf32(const std::string_view input)
     -> std::optional<std::u32string> {
+  // TODO: Replace std::istringstream with std::ispanstream once libc++
+  // supports it (__cpp_lib_spanstream), to avoid copying the input string
   std::istringstream stream{std::string{input}};
   return utf8_to_utf32(stream);
 }
diff --git a/vendor/core/src/core/uri/CMakeLists.txt b/vendor/core/src/core/uri/CMakeLists.txt
index ecc16988b..0272fe7dc 100644
--- a/vendor/core/src/core/uri/CMakeLists.txt
+++ b/vendor/core/src/core/uri/CMakeLists.txt
@@ -6,3 +6,6 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME uri
 if(SOURCEMETA_CORE_INSTALL)
   sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME uri)
 endif()
+
+target_link_libraries(sourcemeta_core_uri
+  PRIVATE sourcemeta::core::ip)
diff --git a/vendor/core/src/core/uri/accessors.cc b/vendor/core/src/core/uri/accessors.cc
index e2fad1735..34a2b7073 100644
--- a/vendor/core/src/core/uri/accessors.cc
+++ b/vendor/core/src/core/uri/accessors.cc
@@ -1,3 +1,4 @@
+#include <sourcemeta/core/ip.h>
 #include <sourcemeta/core/uri.h>
 
 #include <cstdint>  // std::uint32_t
@@ -6,10 +7,7 @@
 
 namespace sourcemeta::core {
 
-auto URI::is_relative() const -> bool {
-  return !this->scheme().has_value() ||
-         (this->path_.has_value() && this->path_.value().starts_with("."));
-}
+auto URI::is_relative() const -> bool { return !this->scheme().has_value(); }
 
 auto URI::is_absolute() const noexcept -> bool {
   return this->scheme_.has_value();
@@ -35,9 +33,14 @@ auto URI::is_file() const -> bool {
   return scheme.has_value() && scheme.value() == "file";
 }
 
+auto URI::is_ipv4() const -> bool {
+  return this->host_.has_value() &&
+         sourcemeta::core::is_ipv4(this->host_.value());
+}
+
 auto URI::is_ipv6() const -> bool {
   return this->host_.has_value() &&
-         this->host_.value().find(':') != std::string::npos;
+         sourcemeta::core::is_ipv6(this->host_.value());
 }
 
 auto URI::is_fragment_only() const -> bool {
diff --git a/vendor/core/src/core/uri/escaping.h b/vendor/core/src/core/uri/escaping.h
index 153bb8bb0..6e1c7bb36 100644
--- a/vendor/core/src/core/uri/escaping.h
+++ b/vendor/core/src/core/uri/escaping.h
@@ -3,7 +3,9 @@
 
 #include "grammar.h"
 
+#include <array>    // std::array
 #include <cctype>   // std::isalnum
+#include <charconv> // std::from_chars
 #include <cstdint>  // std::uint8_t
 #include <istream>  // std::istream
 #include <iterator> // std::istream_iterator
@@ -115,9 +117,11 @@ inline auto uri_unescape(std::istream &input, std::ostream &output) -> void {
   while (iterator != end) {
     if (*iterator == URI_PERCENT && plus_1 != end && plus_2 != end &&
         std::isxdigit(*(plus_1)) && std::isxdigit(*(plus_2))) {
-      std::string hex{*plus_1, *plus_2};
-      char decoded_char = static_cast<char>(std::stoi(hex, nullptr, hex_base));
-      output << decoded_char;
+      const std::array<char, 2> hex{{*plus_1, *plus_2}};
+      int decoded_value{};
+      std::from_chars(hex.data(), hex.data() + hex.size(), decoded_value,
+                      hex_base);
+      output << static_cast<char>(decoded_value);
 
       iterator = std::ranges::next(plus_2, 1, end);
       plus_1 = std::ranges::next(iterator, 1, end);
diff --git a/vendor/core/src/core/uri/include/sourcemeta/core/uri.h b/vendor/core/src/core/uri/include/sourcemeta/core/uri.h
index 418da9e08..59e8727e3 100644
--- a/vendor/core/src/core/uri/include/sourcemeta/core/uri.h
+++ b/vendor/core/src/core/uri/include/sourcemeta/core/uri.h
@@ -152,7 +152,18 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
   /// ```
   [[nodiscard]] auto is_relative() const -> bool;
 
-  /// Check if the host is an ipv6 address. For example:
+  /// Check if the host is an IPv4 address. For example:
+  ///
+  /// ```cpp
+  /// #include <sourcemeta/core/uri.h>
+  /// #include <cassert>
+  ///
+  /// sourcemeta::core::URI uri{"http://192.168.1.1/index.html"};
+  /// assert(uri.is_ipv4());
+  /// ```
+  [[nodiscard]] auto is_ipv4() const -> bool;
+
+  /// Check if the host is an IPv6 address. For example:
   ///
   /// ```cpp
   /// #include <sourcemeta/core/uri.h>
@@ -513,6 +524,7 @@ class SOURCEMETA_CORE_URI_EXPORT URI {
   std::optional<std::string> scheme_{};
   std::optional<std::string> fragment_{};
   std::optional<std::string> query_{};
+  bool ip_literal_{false};
 #if defined(_MSC_VER)
 #pragma warning(default : 4251)
 #endif
diff --git a/vendor/core/src/core/uri/parse.cc b/vendor/core/src/core/uri/parse.cc
index 09acb7d44..6cdad7452 100644
--- a/vendor/core/src/core/uri/parse.cc
+++ b/vendor/core/src/core/uri/parse.cc
@@ -3,15 +3,17 @@
 #include "escaping.h"
 #include "grammar.h"
 
-#include <cassert>   // assert
-#include <cctype>    // std::isalnum, std::isxdigit, std::isalpha, std::isdigit
-#include <cstdint>   // std::uint64_t
-#include <limits>    // std::numeric_limits
-#include <optional>  // std::optional
-#include <stdexcept> // std::out_of_range
-#include <string>    // std::string, std::stoul
-#include <string_view> // std::string_view
-#include <type_traits> // std::conditional_t
+#include <array>    // std::array
+#include <cassert>  // assert
+#include <cctype>   // std::isalnum, std::isxdigit, std::isalpha, std::isdigit
+#include <charconv> // std::from_chars
+#include <cstdint>  // std::uint64_t
+#include <limits>   // std::numeric_limits
+#include <optional> // std::optional
+#include <string>   // std::string
+#include <string_view>  // std::string_view
+#include <system_error> // std::errc
+#include <type_traits>  // std::conditional_t
 
 namespace {
 
@@ -24,7 +26,7 @@ auto validate_percent_encoded_utf8(const std::string_view input,
     return 3;
   }
 
-  if (position + 2 >= input.size()) {
+  if (position + 2 >= input.size()) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(position + 1)};
   }
@@ -32,19 +34,21 @@ auto validate_percent_encoded_utf8(const std::string_view input,
   const auto first_hex = static_cast<unsigned char>(input[position + 1]);
   const auto second_hex = static_cast<unsigned char>(input[position + 2]);
 
-  if (!std::isxdigit(first_hex) || !std::isxdigit(second_hex)) {
+  if (!std::isxdigit(first_hex) || !std::isxdigit(second_hex)) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(position + 1)};
   }
 
-  std::string hex{input[position + 1], input[position + 2]};
-  const auto value = static_cast<unsigned char>(std::stoi(hex, nullptr, 16));
+  const std::array<char, 2> hex{{input[position + 1], input[position + 2]}};
+  int parsed_value{};
+  std::from_chars(hex.data(), hex.data() + hex.size(), parsed_value, 16);
+  const auto value = static_cast<unsigned char>(parsed_value);
 
   if ((value & 0x80) == 0) {
     return 3;
   }
 
-  if ((value & 0xC0) == 0x80) {
+  if ((value & 0xC0) == 0x80) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(position + 1)};
   }
@@ -61,7 +65,7 @@ auto validate_percent_encoded_utf8(const std::string_view input,
   for (std::string::size_type index = 1; index <= continuation_count; ++index) {
     const std::string::size_type next_position = position + (index * 3);
     if (next_position + 2 >= input.size() ||
-        input[next_position] != URI_PERCENT) {
+        input[next_position] != URI_PERCENT) [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -71,16 +75,20 @@ auto validate_percent_encoded_utf8(const std::string_view input,
     const auto cont_second =
         static_cast<unsigned char>(input[next_position + 2]);
 
-    if (!std::isxdigit(cont_first) || !std::isxdigit(cont_second)) {
+    if (!std::isxdigit(cont_first) || !std::isxdigit(cont_second))
+        [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(next_position + 1)};
     }
 
-    std::string cont_hex{input[next_position + 1], input[next_position + 2]};
-    const auto cont_value =
-        static_cast<unsigned char>(std::stoi(cont_hex, nullptr, 16));
+    const std::array<char, 2> cont_hex{
+        {input[next_position + 1], input[next_position + 2]}};
+    int cont_parsed_value{};
+    std::from_chars(cont_hex.data(), cont_hex.data() + cont_hex.size(),
+                    cont_parsed_value, 16);
+    const auto cont_value = static_cast<unsigned char>(cont_parsed_value);
 
-    if ((cont_value & 0xC0) != 0x80) {
+    if ((cont_value & 0xC0) != 0x80) [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(next_position + 1)};
     }
@@ -150,13 +158,16 @@ auto parse_port(const std::string_view input,
   if constexpr (CheckOnly) {
     return true;
   } else {
-    try {
-      const std::string port_string{input.substr(start, position - start)};
-      return std::stoul(port_string);
-    } catch (const std::out_of_range &) {
+    const auto port_view = input.substr(start, position - start);
+    unsigned long port_value{};
+    const auto result = std::from_chars(
+        port_view.data(), port_view.data() + port_view.size(), port_value);
+    if (result.ec != std::errc{}) [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(start + 1)};
     }
+
+    return port_value;
   }
 }
 
@@ -177,7 +188,8 @@ auto parse_ipv6(const std::string_view input,
 
     // Require 1*HEXDIG for the version
     if (position >= input.size() || input[position] == URI_CLOSE_BRACKET ||
-        !std::isxdigit(static_cast<unsigned char>(input[position]))) {
+        !std::isxdigit(static_cast<unsigned char>(input[position])))
+        [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -187,21 +199,22 @@ auto parse_ipv6(const std::string_view input,
     }
 
     // Require "." separator
-    if (position >= input.size() || input[position] != URI_DOT) {
+    if (position >= input.size() || input[position] != URI_DOT) [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
     position += 1;
 
     // Require 1*( unreserved / sub-delims / ":" )
-    if (position >= input.size() || input[position] == URI_CLOSE_BRACKET) {
+    if (position >= input.size() || input[position] == URI_CLOSE_BRACKET)
+        [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
     while (position < input.size() && input[position] != URI_CLOSE_BRACKET) {
       const auto current = input[position];
       if (!uri_is_unreserved(current) && !uri_is_sub_delim(current) &&
-          current != URI_COLON) {
+          current != URI_COLON) [[unlikely]] {
         throw sourcemeta::core::URIParseError{
             static_cast<std::uint64_t>(position + 1)};
       }
@@ -212,7 +225,7 @@ auto parse_ipv6(const std::string_view input,
     while (position < input.size() && input[position] != URI_CLOSE_BRACKET) {
       const auto current = input[position];
       if (!std::isxdigit(static_cast<unsigned char>(current)) &&
-          current != URI_COLON && current != URI_DOT) {
+          current != URI_COLON && current != URI_DOT) [[unlikely]] {
         throw sourcemeta::core::URIParseError{
             static_cast<std::uint64_t>(position + 1)};
       }
@@ -220,7 +233,7 @@ auto parse_ipv6(const std::string_view input,
     }
   }
 
-  if (position >= input.size()) {
+  if (position >= input.size()) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(start + 1)};
   }
@@ -236,7 +249,8 @@ auto parse_ipv6(const std::string_view input,
 
 template <bool CheckOnly>
 auto parse_host(const std::string_view input,
-                std::string_view::size_type &position)
+                std::string_view::size_type &position,
+                [[maybe_unused]] bool &ip_literal)
     -> std::conditional_t<CheckOnly, void, std::string> {
   if (position >= input.size()) {
     if constexpr (!CheckOnly) {
@@ -247,6 +261,7 @@ auto parse_host(const std::string_view input,
   }
 
   if (input[position] == URI_OPEN_BRACKET) {
+    ip_literal = true;
     if constexpr (CheckOnly) {
       parse_ipv6<true>(input, position);
       return;
@@ -268,7 +283,7 @@ auto parse_host(const std::string_view input,
       position += skip;
     } else if (uri_is_unreserved(current) || uri_is_sub_delim(current)) {
       position += 1;
-    } else {
+    } else [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -353,7 +368,7 @@ auto parse_path(const std::string_view input,
       position += skip;
     } else if (uri_is_pchar(current) || current == URI_SLASH) {
       position += 1;
-    } else {
+    } else [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -393,7 +408,7 @@ auto parse_query(const std::string_view input,
     } else if (uri_is_pchar(current) || current == URI_SLASH ||
                current == URI_QUESTION) {
       position += 1;
-    } else {
+    } else [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -430,7 +445,7 @@ auto parse_fragment(const std::string_view input,
     } else if (uri_is_pchar(current) || current == URI_SLASH ||
                current == URI_QUESTION) {
       position += 1;
-    } else {
+    } else [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -448,11 +463,11 @@ auto parse_authority(const std::string_view input,
                      std::string_view::size_type &position,
                      [[maybe_unused]] std::optional<std::string> &userinfo,
                      [[maybe_unused]] std::optional<std::string> &host,
-                     [[maybe_unused]] std::optional<std::uint32_t> &port)
-    -> void {
+                     [[maybe_unused]] std::optional<std::uint32_t> &port,
+                     [[maybe_unused]] bool &ip_literal) -> void {
   if constexpr (CheckOnly) {
     parse_userinfo<true>(input, position);
-    parse_host<true>(input, position);
+    parse_host<true>(input, position, ip_literal);
   } else {
     auto userinfo_raw = parse_userinfo<false>(input, position);
     if (userinfo_raw.has_value()) {
@@ -460,7 +475,7 @@ auto parse_authority(const std::string_view input,
       userinfo = std::move(userinfo_raw.value());
     }
 
-    auto host_raw = parse_host<false>(input, position);
+    auto host_raw = parse_host<false>(input, position, ip_literal);
     uri_unescape_unreserved_inplace(host_raw);
     host = std::move(host_raw);
   }
@@ -475,7 +490,8 @@ auto parse_authority(const std::string_view input,
       const auto port_start = position;
       const auto port_value = parse_port<false>(input, position);
       if (port_value.has_value()) {
-        if (port_value.value() > std::numeric_limits<std::uint32_t>::max()) {
+        if (port_value.value() > std::numeric_limits<std::uint32_t>::max())
+            [[unlikely]] {
           throw sourcemeta::core::URIParseError{
               static_cast<std::uint64_t>(port_start + 1)};
         }
@@ -485,7 +501,7 @@ auto parse_authority(const std::string_view input,
     }
   }
 
-  if (position < input.size() && input[position] == URI_AT) {
+  if (position < input.size() && input[position] == URI_AT) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(position + 1)};
   }
@@ -499,7 +515,8 @@ auto do_parse(const std::string_view input,
               [[maybe_unused]] std::optional<std::uint32_t> &port,
               [[maybe_unused]] std::optional<std::string> &path,
               [[maybe_unused]] std::optional<std::string> &query,
-              [[maybe_unused]] std::optional<std::string> &fragment) -> bool {
+              [[maybe_unused]] std::optional<std::string> &fragment,
+              [[maybe_unused]] bool &ip_literal) -> bool {
   if (input.empty()) {
     return false;
   }
@@ -520,13 +537,15 @@ auto do_parse(const std::string_view input,
 
   if (has_authority) {
     position += 2;
-    parse_authority<CheckOnly>(input, position, userinfo, host, port);
+    parse_authority<CheckOnly>(input, position, userinfo, host, port,
+                               ip_literal);
 
     // RFC 3986: hier-part = "//" authority path-abempty
     // path-abempty = *( "/" segment ), so after authority the next character
     // must be "/", "?", "#", or end-of-input
     if (position < input.size() && input[position] != URI_SLASH &&
-        input[position] != URI_QUESTION && input[position] != URI_HASH) {
+        input[position] != URI_QUESTION && input[position] != URI_HASH)
+        [[unlikely]] {
       throw sourcemeta::core::URIParseError{
           static_cast<std::uint64_t>(position + 1)};
     }
@@ -549,7 +568,8 @@ auto do_parse(const std::string_view input,
           const auto first_slash = path_value.find(URI_SLASH);
           const auto colon_pos = path_value.find(URI_COLON);
           if (colon_pos != std::string::npos &&
-              (first_slash == std::string::npos || colon_pos < first_slash)) {
+              (first_slash == std::string::npos || colon_pos < first_slash))
+              [[unlikely]] {
             throw sourcemeta::core::URIParseError{
                 static_cast<std::uint64_t>(colon_pos + 1)};
           }
@@ -572,8 +592,8 @@ auto do_parse(const std::string_view input,
         const auto first_slash = path_view.find(URI_SLASH);
         const auto colon_pos = path_view.find(URI_COLON);
         if (colon_pos != std::string_view::npos &&
-            (first_slash == std::string_view::npos ||
-             colon_pos < first_slash)) {
+            (first_slash == std::string_view::npos || colon_pos < first_slash))
+            [[unlikely]] {
           throw sourcemeta::core::URIParseError{
               static_cast<std::uint64_t>(path_start + colon_pos + 1)};
         }
@@ -598,7 +618,7 @@ auto do_parse(const std::string_view input,
     }
   }
 
-  if (position < input.size()) {
+  if (position < input.size()) [[unlikely]] {
     throw sourcemeta::core::URIParseError{
         static_cast<std::uint64_t>(position + 1)};
   }
@@ -619,15 +639,17 @@ auto URI::parse(const std::string_view input) -> void {
   assert(!this->query_.has_value());
   assert(!this->fragment_.has_value());
   do_parse<false>(input, this->scheme_, this->userinfo_, this->host_,
-                  this->port_, this->path_, this->query_, this->fragment_);
+                  this->port_, this->path_, this->query_, this->fragment_,
+                  this->ip_literal_);
 }
 
 auto URI::is_uri(const std::string_view input) noexcept -> bool {
   try {
     std::optional<std::string> scheme, userinfo, host, path, query, fragment;
     std::optional<std::uint32_t> port;
+    bool ip_literal{false};
     return do_parse<true>(input, scheme, userinfo, host, port, path, query,
-                          fragment);
+                          fragment, ip_literal);
   } catch (...) {
     return false;
   }
@@ -637,7 +659,9 @@ auto URI::is_uri_reference(const std::string_view input) noexcept -> bool {
   try {
     std::optional<std::string> scheme, userinfo, host, path, query, fragment;
     std::optional<std::uint32_t> port;
-    do_parse<true>(input, scheme, userinfo, host, port, path, query, fragment);
+    bool ip_literal{false};
+    do_parse<true>(input, scheme, userinfo, host, port, path, query, fragment,
+                   ip_literal);
     return true;
   } catch (...) {
     return false;
diff --git a/vendor/core/src/core/uri/recompose.cc b/vendor/core/src/core/uri/recompose.cc
index ec59a20fb..2f8ac5154 100644
--- a/vendor/core/src/core/uri/recompose.cc
+++ b/vendor/core/src/core/uri/recompose.cc
@@ -2,7 +2,9 @@
 
 #include "escaping.h"
 
+#include <array>    // std::array
 #include <cctype>   // std::isxdigit
+#include <charconv> // std::to_chars
 #include <cstdint>  // std::uint32_t
 #include <iomanip>  // std::hex, std::uppercase
 #include <optional> // std::optional
@@ -129,7 +131,7 @@ auto URI::recompose_without_fragment() const -> std::optional<std::string> {
 
   // Host
   if (result_host.has_value()) {
-    if (this->is_ipv6()) {
+    if (this->ip_literal_) {
       result += '[';
       result += result_host.value();
       result += ']';
@@ -142,7 +144,11 @@ auto URI::recompose_without_fragment() const -> std::optional<std::string> {
   // Port
   if (result_port.has_value()) {
     result += ':';
-    result += std::to_string(result_port.value());
+    std::array<char, 20> port_buffer{};
+    const auto [end_pointer, error_code] = std::to_chars(
+        port_buffer.data(), port_buffer.data() + port_buffer.size(),
+        result_port.value());
+    result.append(port_buffer.data(), end_pointer);
   }
 
   // Path
@@ -150,13 +156,7 @@ auto URI::recompose_without_fragment() const -> std::optional<std::string> {
   if (result_path.has_value()) {
     const auto &path_value = result_path.value();
 
-    if (result_scheme.has_value() && !has_authority &&
-        path_value.starts_with("/") && !path_value.starts_with("//")) {
-      escape_component_to_string(result, path_value.substr(1),
-                                 URIEscapeMode::Path);
-    } else {
-      escape_component_to_string(result, path_value, URIEscapeMode::Path);
-    }
+    escape_component_to_string(result, path_value, URIEscapeMode::Path);
   }
 
   // Query
diff --git a/vendor/core/src/core/uri/resolution.cc b/vendor/core/src/core/uri/resolution.cc
index 919023111..9982b1815 100644
--- a/vendor/core/src/core/uri/resolution.cc
+++ b/vendor/core/src/core/uri/resolution.cc
@@ -124,8 +124,7 @@ auto URI::resolve_from(const URI &base) -> URI & {
     const auto base_path = base.path_.value_or("");
     if (!base_path.starts_with('/') && this->path_.has_value()) {
       const auto &ref_path = this->path_.value();
-      if (!ref_path.starts_with('/') &&
-          ref_path.find('/') == std::string::npos) {
+      if (!ref_path.starts_with('/') && !ref_path.contains('/')) {
         auto merged = merge_paths(base_path, ref_path, false);
         this->path_ = remove_dot_segments(merged);
         return *this;
diff --git a/vendor/core/src/core/uritemplate/include/sourcemeta/core/uritemplate_router.h b/vendor/core/src/core/uritemplate/include/sourcemeta/core/uritemplate_router.h
index 763a7f8b8..649af7499 100644
--- a/vendor/core/src/core/uritemplate/include/sourcemeta/core/uritemplate_router.h
+++ b/vendor/core/src/core/uritemplate/include/sourcemeta/core/uritemplate_router.h
@@ -5,12 +5,15 @@
 #include <sourcemeta/core/uritemplate_export.h>
 #endif
 
-#include <cstddef>     // std::size_t
-#include <cstdint>     // std::uint16_t, std::uint32_t, std::uint8_t
+#include <cstddef> // std::size_t
+#include <cstdint> // std::uint16_t, std::uint32_t, std::uint8_t, std::int64_t
 #include <filesystem>  // std::filesystem::path
 #include <functional>  // std::function
 #include <memory>      // std::unique_ptr
+#include <span>        // std::span
 #include <string_view> // std::string_view
+#include <utility>     // std::pair
+#include <variant>     // std::variant
 #include <vector>      // std::vector
 
 namespace sourcemeta::core {
@@ -36,6 +39,11 @@ class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouter {
   using Callback =
       std::function<void(Index, std::string_view, std::string_view)>;
 
+  using ArgumentValue = std::variant<std::string_view, std::int64_t, bool>;
+  using Argument = std::pair<std::string_view, ArgumentValue>;
+  using ArgumentCallback =
+      std::function<void(std::string_view, const ArgumentValue &)>;
+
   /// The type of a node in the router trie
   enum class NodeType : std::uint8_t {
     Root = 0,
@@ -68,8 +76,8 @@ class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouter {
 
   /// Add a route to the router. Make sure the string lifetime survives the
   /// router
-  auto add(const std::string_view uri_template, const Identifier identifier)
-      -> void;
+  auto add(const std::string_view uri_template, const Identifier identifier,
+           const std::span<const Argument> arguments = {}) -> void;
 
   /// Match a path against the router. Note the callback might fire for
   /// initial matches even though the entire match might still fail
@@ -79,8 +87,17 @@ class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouter {
   /// Access the root node of the trie
   [[nodiscard]] auto root() const noexcept -> const Node &;
 
+  /// Access the stored arguments for a given route identifier
+  auto arguments(const Identifier identifier,
+                 const ArgumentCallback &callback) const -> void;
+
+  /// Access all stored route arguments
+  [[nodiscard]] auto arguments() const noexcept
+      -> const std::vector<std::pair<Identifier, std::vector<Argument>>> &;
+
 private:
   Node root_;
+  std::vector<std::pair<Identifier, std::vector<Argument>>> arguments_;
 };
 
 /// @ingroup uritemplate
@@ -126,6 +143,11 @@ class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterView {
                            const URITemplateRouter::Callback &callback) const
       -> URITemplateRouter::Identifier;
 
+  /// Access the stored arguments for a given route identifier
+  auto arguments(const URITemplateRouter::Identifier identifier,
+                 const URITemplateRouter::ArgumentCallback &callback) const
+      -> void;
+
 private:
   std::vector<std::uint8_t> data_;
 };
diff --git a/vendor/core/src/core/uritemplate/uritemplate_router.cc b/vendor/core/src/core/uritemplate/uritemplate_router.cc
index 2fedf1421..aa464af24 100644
--- a/vendor/core/src/core/uritemplate/uritemplate_router.cc
+++ b/vendor/core/src/core/uritemplate/uritemplate_router.cc
@@ -95,11 +95,22 @@ inline auto extract_segment(const char *start, const char *end)
 } // namespace
 
 auto URITemplateRouter::add(const std::string_view uri_template,
-                            const Identifier identifier) -> void {
+                            const Identifier identifier,
+                            const std::span<const Argument> arguments) -> void {
   assert(identifier > 0);
 
   if (uri_template.empty()) {
     this->root_.identifier = identifier;
+    if (!arguments.empty()) {
+      assert(std::ranges::none_of(this->arguments_,
+                                  [&identifier](const auto &entry) {
+                                    return entry.first == identifier;
+                                  }));
+      this->arguments_.emplace_back(
+          identifier,
+          std::vector<Argument>{arguments.begin(), arguments.end()});
+    }
+
     return;
   }
 
@@ -257,6 +268,15 @@ auto URITemplateRouter::add(const std::string_view uri_template,
 
   if (!absorbed && current != nullptr) {
     current->identifier = identifier;
+    if (!arguments.empty()) {
+      assert(std::ranges::none_of(this->arguments_,
+                                  [&identifier](const auto &entry) {
+                                    return entry.first == identifier;
+                                  }));
+      this->arguments_.emplace_back(
+          identifier,
+          std::vector<Argument>{arguments.begin(), arguments.end()});
+    }
   }
 }
 
@@ -264,6 +284,25 @@ auto URITemplateRouter::root() const noexcept -> const Node & {
   return this->root_;
 }
 
+auto URITemplateRouter::arguments(const Identifier identifier,
+                                  const ArgumentCallback &callback) const
+    -> void {
+  for (const auto &entry : this->arguments_) {
+    if (entry.first == identifier) {
+      for (const auto &argument : entry.second) {
+        callback(argument.first, argument.second);
+      }
+
+      return;
+    }
+  }
+}
+
+auto URITemplateRouter::arguments() const noexcept
+    -> const std::vector<std::pair<Identifier, std::vector<Argument>>> & {
+  return this->arguments_;
+}
+
 auto URITemplateRouter::match(const std::string_view path,
                               const Callback &callback) const -> Identifier {
   if (path.empty()) {
diff --git a/vendor/core/src/core/uritemplate/uritemplate_router_view.cc b/vendor/core/src/core/uritemplate/uritemplate_router_view.cc
index b51902950..2a2b876ac 100644
--- a/vendor/core/src/core/uritemplate/uritemplate_router_view.cc
+++ b/vendor/core/src/core/uritemplate/uritemplate_router_view.cc
@@ -1,6 +1,7 @@
 #include <sourcemeta/core/uritemplate.h>
 
-#include <cstring>       // std::memcmp
+#include <cassert>       // assert
+#include <cstring>       // std::memcmp, std::memcpy
 #include <fstream>       // std::ofstream, std::ifstream
 #include <limits>        // std::numeric_limits
 #include <queue>         // std::queue
@@ -13,14 +14,26 @@ namespace sourcemeta::core {
 namespace {
 
 constexpr std::uint32_t ROUTER_MAGIC = 0x52544552; // "RTER"
-constexpr std::uint32_t ROUTER_VERSION = 1;
+constexpr std::uint32_t ROUTER_VERSION = 2;
 constexpr std::uint32_t NO_CHILD = std::numeric_limits<std::uint32_t>::max();
 
+// Type tags for argument value serialization
+constexpr std::uint8_t ARGUMENT_TYPE_STRING = 0x00;
+constexpr std::uint8_t ARGUMENT_TYPE_INTEGER = 0x01;
+constexpr std::uint8_t ARGUMENT_TYPE_BOOLEAN = 0x02;
+
 struct RouterHeader {
   std::uint32_t magic;
   std::uint32_t version;
   std::uint32_t node_count;
   std::uint32_t string_table_offset;
+  std::uint32_t arguments_offset;
+};
+
+struct ArgumentEntryHeader {
+  std::uint16_t identifier;
+  std::uint32_t blob_offset;
+  std::uint32_t blob_length;
 };
 
 // Binary search for a literal child matching the given segment
@@ -150,12 +163,75 @@ auto URITemplateRouterView::save(const URITemplateRouter &router,
     nodes.push_back(serialized);
   }
 
+  // Build the arguments section
+  const auto &route_arguments = router.arguments();
+  const auto entry_count = static_cast<std::uint16_t>(route_arguments.size());
+
+  // Build per-entry blobs
+  std::vector<ArgumentEntryHeader> argument_entries;
+  std::vector<std::uint8_t> argument_blob;
+  argument_entries.reserve(entry_count);
+
+  for (const auto &[identifier, arguments] : route_arguments) {
+    ArgumentEntryHeader entry{};
+    entry.identifier = identifier;
+    entry.blob_offset = static_cast<std::uint32_t>(argument_blob.size());
+
+    assert(arguments.size() <= std::numeric_limits<std::uint16_t>::max());
+    const auto arg_count = static_cast<std::uint16_t>(arguments.size());
+    argument_blob.push_back(static_cast<std::uint8_t>(arg_count & 0xFF));
+    argument_blob.push_back(static_cast<std::uint8_t>(arg_count >> 8));
+
+    for (const auto &[name, value] : arguments) {
+      // Write key_length + key_bytes
+      assert(name.size() <= std::numeric_limits<std::uint16_t>::max());
+      const auto key_length = static_cast<std::uint16_t>(name.size());
+      argument_blob.push_back(static_cast<std::uint8_t>(key_length & 0xFF));
+      argument_blob.push_back(static_cast<std::uint8_t>(key_length >> 8));
+      argument_blob.insert(argument_blob.end(), name.begin(), name.end());
+
+      // Write type_tag + value_length + value_bytes
+      if (std::holds_alternative<std::string_view>(value)) {
+        const auto string_value = std::get<std::string_view>(value);
+        assert(string_value.size() <=
+               std::numeric_limits<std::uint16_t>::max());
+        const auto value_length =
+            static_cast<std::uint16_t>(string_value.size());
+        argument_blob.push_back(ARGUMENT_TYPE_STRING);
+        argument_blob.push_back(static_cast<std::uint8_t>(value_length & 0xFF));
+        argument_blob.push_back(static_cast<std::uint8_t>(value_length >> 8));
+        argument_blob.insert(argument_blob.end(), string_value.begin(),
+                             string_value.end());
+      } else if (std::holds_alternative<std::int64_t>(value)) {
+        const auto integer_value = std::get<std::int64_t>(value);
+        argument_blob.push_back(ARGUMENT_TYPE_INTEGER);
+        argument_blob.push_back(8);
+        argument_blob.push_back(0);
+        const auto old_size = argument_blob.size();
+        argument_blob.resize(old_size + 8);
+        std::memcpy(argument_blob.data() + old_size, &integer_value, 8);
+      } else {
+        const auto boolean_value = std::get<bool>(value);
+        argument_blob.push_back(ARGUMENT_TYPE_BOOLEAN);
+        argument_blob.push_back(1);
+        argument_blob.push_back(0);
+        argument_blob.push_back(boolean_value ? 1 : 0);
+      }
+    }
+
+    entry.blob_length =
+        static_cast<std::uint32_t>(argument_blob.size()) - entry.blob_offset;
+    argument_entries.push_back(entry);
+  }
+
   RouterHeader header{};
   header.magic = ROUTER_MAGIC;
   header.version = ROUTER_VERSION;
   header.node_count = static_cast<std::uint32_t>(nodes.size());
   header.string_table_offset = static_cast<std::uint32_t>(
       sizeof(RouterHeader) + nodes.size() * sizeof(Node));
+  header.arguments_offset = static_cast<std::uint32_t>(
+      header.string_table_offset + string_table.size());
 
   std::ofstream file(path, std::ios::binary);
   if (!file) {
@@ -168,6 +244,22 @@ auto URITemplateRouterView::save(const URITemplateRouter &router,
   file.write(string_table.data(),
              static_cast<std::streamsize>(string_table.size()));
 
+  // Write arguments section
+  file.write(reinterpret_cast<const char *>(&entry_count), sizeof(entry_count));
+  for (const auto &entry : argument_entries) {
+    file.write(reinterpret_cast<const char *>(&entry.identifier),
+               sizeof(entry.identifier));
+    file.write(reinterpret_cast<const char *>(&entry.blob_offset),
+               sizeof(entry.blob_offset));
+    file.write(reinterpret_cast<const char *>(&entry.blob_length),
+               sizeof(entry.blob_length));
+  }
+
+  if (!argument_blob.empty()) {
+    file.write(reinterpret_cast<const char *>(argument_blob.data()),
+               static_cast<std::streamsize>(argument_blob.size()));
+  }
+
   if (!file) {
     throw URITemplateRouterSaveError{path,
                                      "Failed to write router data to file"};
@@ -229,10 +321,15 @@ auto URITemplateRouterView::match(const std::string_view path,
     return 0;
   }
 
+  if (header->arguments_offset < header->string_table_offset ||
+      header->arguments_offset > this->data_.size()) {
+    return 0;
+  }
+
   const auto *string_table = reinterpret_cast<const char *>(
       this->data_.data() + header->string_table_offset);
   const auto string_table_size =
-      this->data_.size() - header->string_table_offset;
+      header->arguments_offset - header->string_table_offset;
 
   // Empty path matches empty template
   if (path.empty()) {
@@ -356,4 +453,150 @@ auto URITemplateRouterView::match(const std::string_view path,
   return nodes[current_node].identifier;
 }
 
+auto URITemplateRouterView::arguments(
+    const URITemplateRouter::Identifier identifier,
+    const URITemplateRouter::ArgumentCallback &callback) const -> void {
+  if (this->data_.size() < sizeof(RouterHeader)) {
+    return;
+  }
+
+  const auto *header =
+      reinterpret_cast<const RouterHeader *>(this->data_.data());
+  if (header->magic != ROUTER_MAGIC || header->version != ROUTER_VERSION) {
+    return;
+  }
+
+  const auto arguments_start =
+      static_cast<std::size_t>(header->arguments_offset);
+  const auto data_size = this->data_.size();
+  if (arguments_start >= data_size) {
+    return;
+  }
+
+  const auto section_size = data_size - arguments_start;
+  if (section_size < sizeof(std::uint16_t)) {
+    return;
+  }
+
+  std::uint16_t entry_count = 0;
+  std::memcpy(&entry_count, this->data_.data() + arguments_start,
+              sizeof(entry_count));
+  if (entry_count == 0) {
+    return;
+  }
+
+  constexpr std::size_t ENTRY_SIZE =
+      sizeof(std::uint16_t) + sizeof(std::uint32_t) + sizeof(std::uint32_t);
+  const auto entries_offset = arguments_start + sizeof(entry_count);
+  const auto entries_size = static_cast<std::size_t>(entry_count) * ENTRY_SIZE;
+  if (entries_size > data_size - entries_offset) {
+    return;
+  }
+
+  const auto blob_area_offset = entries_offset + entries_size;
+
+  for (std::uint16_t index = 0; index < entry_count; ++index) {
+    const auto entry_offset = entries_offset + index * ENTRY_SIZE;
+
+    std::uint16_t entry_identifier = 0;
+    std::memcpy(&entry_identifier, this->data_.data() + entry_offset,
+                sizeof(entry_identifier));
+    if (entry_identifier != identifier) {
+      continue;
+    }
+
+    std::uint32_t blob_offset = 0;
+    std::uint32_t blob_length = 0;
+    std::memcpy(&blob_offset,
+                this->data_.data() + entry_offset + sizeof(std::uint16_t),
+                sizeof(blob_offset));
+    std::memcpy(&blob_length,
+                this->data_.data() + entry_offset + sizeof(std::uint16_t) +
+                    sizeof(std::uint32_t),
+                sizeof(blob_length));
+
+    const auto blob_abs_offset = blob_area_offset + blob_offset;
+    if (blob_offset > data_size - blob_area_offset ||
+        blob_length > data_size - blob_abs_offset ||
+        blob_length < sizeof(std::uint16_t)) {
+      return;
+    }
+
+    std::uint16_t arg_count = 0;
+    std::memcpy(&arg_count, this->data_.data() + blob_abs_offset,
+                sizeof(arg_count));
+    auto cursor = blob_abs_offset + sizeof(arg_count);
+    const auto blob_end = blob_abs_offset + blob_length;
+
+    for (std::uint16_t arg_index = 0; arg_index < arg_count; ++arg_index) {
+      if (cursor + sizeof(std::uint16_t) > blob_end) {
+        return;
+      }
+
+      std::uint16_t key_length = 0;
+      std::memcpy(&key_length, this->data_.data() + cursor, sizeof(key_length));
+      cursor += sizeof(key_length);
+      if (key_length > blob_end - cursor) {
+        return;
+      }
+
+      const std::string_view name{
+          reinterpret_cast<const char *>(this->data_.data() + cursor),
+          key_length};
+      cursor += key_length;
+
+      if (cursor + sizeof(std::uint8_t) + sizeof(std::uint16_t) > blob_end) {
+        return;
+      }
+
+      const auto type_tag = this->data_[cursor];
+      cursor += sizeof(std::uint8_t);
+      std::uint16_t value_length = 0;
+      std::memcpy(&value_length, this->data_.data() + cursor,
+                  sizeof(value_length));
+      cursor += sizeof(value_length);
+      if (value_length > blob_end - cursor) {
+        return;
+      }
+
+      switch (type_tag) {
+        case ARGUMENT_TYPE_STRING: {
+          const std::string_view string_value{
+              reinterpret_cast<const char *>(this->data_.data() + cursor),
+              value_length};
+          callback(name, string_value);
+          break;
+        }
+
+        case ARGUMENT_TYPE_INTEGER: {
+          if (value_length != 8) {
+            return;
+          }
+
+          std::int64_t integer_value = 0;
+          std::memcpy(&integer_value, this->data_.data() + cursor, 8);
+          callback(name, integer_value);
+          break;
+        }
+
+        case ARGUMENT_TYPE_BOOLEAN: {
+          if (value_length != 1) {
+            return;
+          }
+
+          callback(name, this->data_[cursor] != 0);
+          break;
+        }
+
+        default:
+          return;
+      }
+
+      cursor += value_length;
+    }
+
+    return;
+  }
+}
+
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/core/yaml/lexer.h b/vendor/core/src/core/yaml/lexer.h
index 3e9a6aea2..6cfc07afd 100644
--- a/vendor/core/src/core/yaml/lexer.h
+++ b/vendor/core/src/core/yaml/lexer.h
@@ -4,12 +4,14 @@
 #include <sourcemeta/core/unicode.h>
 #include <sourcemeta/core/yaml_error.h>
 
-#include <cstdint>     // std::uint8_t, std::uint64_t
-#include <deque>       // std::deque
-#include <optional>    // std::optional
-#include <string>      // std::string
-#include <string_view> // std::string_view
-#include <vector>      // std::vector
+#include <charconv>     // std::from_chars
+#include <cstdint>      // std::uint8_t, std::uint64_t
+#include <deque>        // std::deque
+#include <optional>     // std::optional
+#include <string>       // std::string
+#include <string_view>  // std::string_view
+#include <system_error> // std::errc
+#include <vector>       // std::vector
 
 namespace sourcemeta::core::yaml {
 
@@ -110,7 +112,7 @@ class Lexer {
     if (this->tab_at_line_start_) {
       this->tab_at_line_start_ = false;
       const char next_char{this->peek()};
-      if (next_char != '{' && next_char != '[') {
+      if (next_char != '{' && next_char != '[') [[unlikely]] {
         throw YAMLParseError{current_line, current_column,
                              "Tab characters cannot be used for indentation"};
       }
@@ -251,7 +253,7 @@ class Lexer {
       return this->scan_block_scalar(ScalarStyle::Folded);
     }
 
-    if (current == '#') {
+    if (current == '#') [[unlikely]] {
       throw YAMLParseError{current_line, current_column,
                            "Unexpected '#' character"};
     }
@@ -518,7 +520,7 @@ class Lexer {
 
     if (this->position_ < this->input_.size() && this->flow_level_ == 0) {
       const char after_tag{this->peek()};
-      if (after_tag == ',') {
+      if (after_tag == ',') [[unlikely]] {
         throw YAMLParseError{this->line_, this->column_,
                              "Invalid character after tag in block context"};
       }
@@ -596,7 +598,7 @@ class Lexer {
       }
     }
 
-    if (!found_closing_quote) {
+    if (!found_closing_quote) [[unlikely]] {
       throw YAMLParseError{start_line, start_column,
                            "Missing closing quote in single-quoted scalar"};
     }
@@ -676,13 +678,13 @@ class Lexer {
       return;
     }
     if (this->column_ == 1 && (this->check_document_marker('-') ||
-                               this->check_document_marker('.'))) {
+                               this->check_document_marker('.'))) [[unlikely]] {
       throw YAMLParseError{this->line_, this->column_,
                            "Document marker inside flow scalar"};
     }
     if (this->flow_level_ == 0 && this->block_indent_ != SIZE_MAX) {
       const auto current_indent{static_cast<std::size_t>(this->column_ - 1)};
-      if (current_indent <= this->block_indent_) {
+      if (current_indent <= this->block_indent_) [[unlikely]] {
         throw YAMLParseError{this->line_, this->column_,
                              "Insufficient indentation in flow scalar"};
       }
@@ -842,7 +844,7 @@ class Lexer {
       }
     }
 
-    if (!found_closing_quote) {
+    if (!found_closing_quote) [[unlikely]] {
       throw YAMLParseError{start_line, start_column,
                            "Missing closing quote in double-quoted scalar"};
     }
@@ -871,21 +873,16 @@ class Lexer {
       this->advance(1);
     }
 
-    if (hex.size() != digits) {
+    if (hex.size() != digits) [[unlikely]] {
       throw YAMLParseError{this->line_, this->column_,
                            "Truncated hex escape sequence"};
     }
 
-    std::size_t parsed{0};
     unsigned long codepoint{};
-    try {
-      codepoint = std::stoul(hex, &parsed, 16);
-    } catch (...) {
-      throw YAMLParseError{this->line_, this->column_,
-                           "Invalid hex escape sequence"};
-    }
-
-    if (parsed != hex.size()) {
+    const auto result =
+        std::from_chars(hex.data(), hex.data() + hex.size(), codepoint, 16);
+    if (result.ec != std::errc{} || result.ptr != hex.data() + hex.size())
+        [[unlikely]] {
       throw YAMLParseError{this->line_, this->column_,
                            "Invalid hex escape sequence"};
     }
@@ -974,7 +971,8 @@ class Lexer {
       this->line_ = saved_line;
       this->column_ = saved_column;
 
-      if (max_leading_empty_indent > content_indent && content_indent > 0) {
+      if (max_leading_empty_indent > content_indent && content_indent > 0)
+          [[unlikely]] {
         throw YAMLParseError{
             start_line, start_column,
             "Leading empty line has more spaces than content indentation"};
@@ -1244,7 +1242,8 @@ class Lexer {
       const char first{this->peek()};
       if (first == '-' || first == '?' || first == ':') {
         const char after{this->peek(1)};
-        if (after == '\0' || is_whitespace(after) || is_flow_indicator(after)) {
+        if (after == '\0' || is_whitespace(after) || is_flow_indicator(after))
+            [[unlikely]] {
           throw YAMLParseError{start_line, start_column,
                                "Invalid plain scalar start in flow context"};
         }
diff --git a/vendor/core/src/core/yaml/parser.h b/vendor/core/src/core/yaml/parser.h
index 34daea523..85dc740e8 100644
--- a/vendor/core/src/core/yaml/parser.h
+++ b/vendor/core/src/core/yaml/parser.h
@@ -54,14 +54,16 @@ class Parser {
       }
     } else {
       token = this->lexer_->next();
-      if (!token.has_value() || token->type != TokenType::StreamStart) {
+      if (!token.has_value() || token->type != TokenType::StreamStart)
+          [[unlikely]] {
         throw YAMLParseError{this->lexer_->line(), this->lexer_->column(),
                              "Expected stream start"};
       }
       token = this->lexer_->next();
     }
 
-    if (!token.has_value() || token->type == TokenType::StreamEnd) {
+    if (!token.has_value() || token->type == TokenType::StreamEnd)
+        [[unlikely]] {
       throw YAMLParseError{1, 1, "Empty YAML document"};
     }
 
@@ -94,13 +96,15 @@ class Parser {
         }
         return JSON{nullptr};
       }
-    } else if (!token.has_value() || token->type == TokenType::StreamEnd) {
+    } else if (!token.has_value() || token->type == TokenType::StreamEnd)
+        [[unlikely]] {
       throw YAMLParseError{1, 1, "Empty YAML document"};
     } else if (token->type == TokenType::DocumentEnd) {
       while (token.has_value() && token->type == TokenType::DocumentEnd) {
         token = this->lexer_->next();
       }
-      if (!token.has_value() || token->type == TokenType::StreamEnd) {
+      if (!token.has_value() || token->type == TokenType::StreamEnd)
+          [[unlikely]] {
         throw YAMLParseError{1, 1, "Empty YAML document"};
       }
       this->pending_tokens_.push_back(token.value());
@@ -194,7 +198,7 @@ class Parser {
       if (token->type == TokenType::DirectiveYAML ||
           token->type == TokenType::DirectiveTag ||
           token->type == TokenType::DirectiveReserved) {
-        if (!saw_document_end) {
+        if (!saw_document_end) [[unlikely]] {
           throw YAMLParseError{token->line, token->column,
                                "Directive not allowed without preceding "
                                "document end marker"};
@@ -202,7 +206,8 @@ class Parser {
         this->process_directives(token.value());
         continue;
       }
-      if (!saw_document_end && token->type != TokenType::DocumentStart) {
+      if (!saw_document_end && token->type != TokenType::DocumentStart)
+          [[unlikely]] {
         throw YAMLParseError{token->line, token->column,
                              "Unexpected content after document"};
       }
@@ -224,13 +229,13 @@ class Parser {
            token.type == TokenType::DirectiveTag ||
            token.type == TokenType::DirectiveReserved) {
       if (token.type == TokenType::DirectiveYAML) {
-        if (seen_yaml_directive) {
+        if (seen_yaml_directive) [[unlikely]] {
           throw YAMLParseError{token.line, token.column,
                                "Duplicate %YAML directive"};
         }
         seen_yaml_directive = true;
         const auto content{token.value};
-        auto cursor{static_cast<std::size_t>(5)};
+        auto cursor{5uz};
         while (cursor < content.size() &&
                (content[cursor] == ' ' || content[cursor] == '\t')) {
           cursor++;
@@ -243,13 +248,13 @@ class Parser {
                (content[cursor] == ' ' || content[cursor] == '\t')) {
           cursor++;
         }
-        if (cursor < content.size() && content[cursor] != '#') {
+        if (cursor < content.size() && content[cursor] != '#') [[unlikely]] {
           throw YAMLParseError{token.line, token.column,
                                "Invalid content in %YAML directive"};
         }
       } else if (token.type == TokenType::DirectiveTag) {
         const auto content{token.value};
-        auto cursor{static_cast<std::size_t>(4)};
+        auto cursor{4uz};
         while (cursor < content.size() &&
                (content[cursor] == ' ' || content[cursor] == '\t')) {
           cursor++;
@@ -390,9 +395,10 @@ class Parser {
         const auto value_indent{
             current_token.column > 0
                 ? static_cast<std::size_t>(current_token.column - 1)
-                : static_cast<std::size_t>(0)};
+                : 0uz};
         const auto parent_indent{this->lexer_->block_indent()};
-        if (parent_indent != SIZE_MAX && value_indent <= parent_indent) {
+        if (parent_indent != SIZE_MAX && value_indent <= parent_indent)
+            [[unlikely]] {
           throw YAMLParseError{current_token.line, current_token.column,
                                "Node property at wrong indentation level"};
         }
@@ -462,7 +468,7 @@ class Parser {
         const auto entry_indent{
             current_token.column > 0
                 ? static_cast<std::size_t>(current_token.column - 1)
-                : static_cast<std::size_t>(0)};
+                : 0uz};
         if (block_indent != SIZE_MAX && entry_indent <= block_indent) {
           this->pending_tokens_.push_back(current_token);
           this->register_anchored_null(anchor_name.value(), token, context,
@@ -495,7 +501,7 @@ class Parser {
 
     if ((anchor_name.has_value() || tag.has_value()) &&
         this->lexer_->flow_level() == 0 && current_token.line == prefix_line &&
-        current_token.type == TokenType::BlockSequenceEntry) {
+        current_token.type == TokenType::BlockSequenceEntry) [[unlikely]] {
       throw YAMLParseError{current_token.line, current_token.column,
                            "Block sequence after node property must start "
                            "on a new line"};
@@ -512,19 +518,19 @@ class Parser {
       case TokenType::Scalar: {
         auto next{this->next_token()};
         if (next.has_value() && next->type == TokenType::BlockMappingValue) {
-          if (current_token.multiline) {
+          if (current_token.multiline) [[unlikely]] {
             throw YAMLParseError{current_token.line, current_token.column,
                                  "Multi-line implicit mapping key"};
           }
           if (this->lexer_->flow_level() > 0 &&
-              next->line != current_token.line) {
+              next->line != current_token.line) [[unlikely]] {
             throw YAMLParseError{next->line, next->column,
                                  "Implicit key and value indicator on "
                                  "different lines in flow context"};
           }
           if (this->lexer_->flow_level() == 0 &&
               context == JSON::ParseContext::Property && key_line > 0 &&
-              current_token.line == key_line) {
+              current_token.line == key_line) [[unlikely]] {
             throw YAMLParseError{current_token.line, current_token.column,
                                  "Implicit mapping key in block value on "
                                  "same line as parent key"};
@@ -532,7 +538,7 @@ class Parser {
           if (this->lexer_->flow_level() == 0 &&
               (anchor_name.has_value() || tag.has_value()) &&
               this->document_start_line_ > 0 &&
-              current_token.line == this->document_start_line_) {
+              current_token.line == this->document_start_line_) [[unlikely]] {
             throw YAMLParseError{
                 current_token.line, current_token.column,
                 "Node properties before implicit mapping key on "
@@ -553,7 +559,7 @@ class Parser {
               current_token, context, index, property, key_line, key_column,
               node_start_column);
         } else {
-          if (anchor_count > 1) {
+          if (anchor_count > 1) [[unlikely]] {
             throw YAMLParseError{current_token.line, current_token.column,
                                  "Multiple anchors on a scalar node"};
           }
@@ -589,7 +595,7 @@ class Parser {
         if (next.has_value() && next->type == TokenType::BlockMappingValue) {
           const std::string alias_name{current_token.value};
           const auto iterator{this->anchors_.find(alias_name)};
-          if (iterator == this->anchors_.end()) {
+          if (iterator == this->anchors_.end()) [[unlikely]] {
             throw YAMLUnknownAnchorError{alias_name, current_token.line,
                                          current_token.column};
           }
@@ -602,7 +608,7 @@ class Parser {
               key_token, context, index, property, key_line, key_column,
               node_start_column);
         } else {
-          if (anchor_name.has_value()) {
+          if (anchor_name.has_value()) [[unlikely]] {
             throw YAMLParseError{current_token.line, current_token.column,
                                  "Cannot anchor an alias node"};
           }
@@ -905,7 +911,7 @@ class Parser {
           key_tag = this->resolve_tag(key_token.value);
         }
         token = this->next_token();
-        if (!token.has_value()) {
+        if (!token.has_value()) [[unlikely]] {
           throw YAMLParseError{this->lexer_->line(), this->lexer_->column(),
                                "Unexpected end of input in flow mapping"};
         }
@@ -921,12 +927,12 @@ class Parser {
         key = std::string{key_token.value};
         this->record_key_scalar_style(key, key_token.scalar_style,
                                       key_token.quoted_original);
-      } else {
+      } else [[unlikely]] {
         throw YAMLParseError{key_token.line, key_token.column,
                              "Expected scalar key in mapping"};
       }
 
-      if (seen_keys.contains(key)) {
+      if (seen_keys.contains(key)) [[unlikely]] {
         throw YAMLDuplicateKeyError{key, key_token.line, key_token.column};
       }
       seen_keys.insert(key);
@@ -934,7 +940,7 @@ class Parser {
       if (key_token.type != TokenType::BlockMappingValue) {
         token = this->next_token();
 
-        if (!token.has_value()) {
+        if (!token.has_value()) [[unlikely]] {
           throw YAMLParseError{this->lexer_->line(), this->lexer_->column(),
                                "Unexpected end of input in flow mapping"};
         }
@@ -948,7 +954,7 @@ class Parser {
           continue;
         }
 
-        if (token->type != TokenType::BlockMappingValue) {
+        if (token->type != TokenType::BlockMappingValue) [[unlikely]] {
           const auto colon_column{key_token.column +
                                   static_cast<std::uint64_t>(key.size())};
           throw YAMLParseError{key_token.line, colon_column,
@@ -957,7 +963,7 @@ class Parser {
       }
 
       token = this->next_token();
-      if (!token.has_value()) {
+      if (!token.has_value()) [[unlikely]] {
         throw YAMLParseError{this->lexer_->line(), this->lexer_->column(),
                              "Expected value after ':'"};
       }
@@ -983,7 +989,7 @@ class Parser {
           found_compact_separator = true;
         }
         if (token.has_value() && token->type != TokenType::FlowEntry &&
-            token->type != TokenType::MappingEnd) {
+            token->type != TokenType::MappingEnd) [[unlikely]] {
           throw YAMLParseError{token->line, token->column,
                                "Missing comma between flow mapping entries"};
         }
@@ -1026,15 +1032,15 @@ class Parser {
       if (parent_block_indent != SIZE_MAX && token->line != start_token.line) {
         const auto token_indent{
             token->column > 0 ? static_cast<std::size_t>(token->column - 1)
-                              : static_cast<std::size_t>(0)};
-        if (token_indent <= parent_block_indent) {
+                              : 0uz};
+        if (token_indent <= parent_block_indent) [[unlikely]] {
           throw YAMLParseError{
               token->line, token->column,
               "Flow content indented less than or equal to parent block level"};
         }
       }
       if (token->type == TokenType::FlowEntry) {
-        if (element_index == 0) {
+        if (element_index == 0) [[unlikely]] {
           throw YAMLParseError{token->line, token->column,
                                "Leading comma in flow sequence"};
         }
@@ -1042,7 +1048,8 @@ class Parser {
           found_compact_separator = true;
         }
         token = this->next_token();
-        if (token.has_value() && token->type == TokenType::FlowEntry) {
+        if (token.has_value() && token->type == TokenType::FlowEntry)
+            [[unlikely]] {
           throw YAMLParseError{token->line, token->column,
                                "Empty entry in flow sequence"};
         }
@@ -1052,7 +1059,7 @@ class Parser {
       if (token->type == TokenType::BlockMappingKey) {
         auto mapping{JSON::make_object()};
         token = this->next_token();
-        if (!token.has_value()) {
+        if (!token.has_value()) [[unlikely]] {
           throw YAMLParseError{this->lexer_->line(), this->lexer_->column(),
                                "Unexpected end after explicit key in flow"};
         }
@@ -1100,7 +1107,7 @@ class Parser {
         found_compact_separator = true;
       }
       if (token.has_value() && token->type != TokenType::FlowEntry &&
-          token->type != TokenType::SequenceEnd) {
+          token->type != TokenType::SequenceEnd) [[unlikely]] {
         throw YAMLParseError{token->line, token->column,
                              "Missing comma in flow sequence"};
       }
@@ -1135,9 +1142,8 @@ class Parser {
     JSON result{JSON::make_array()};
     std::size_t element_index{0};
     const auto base_column{start_token.column};
-    const auto sequence_indent{base_column > 0
-                                   ? static_cast<std::size_t>(base_column - 1)
-                                   : static_cast<std::size_t>(0)};
+    const auto sequence_indent{
+        base_column > 0 ? static_cast<std::size_t>(base_column - 1) : 0uz};
     this->detect_indent_width(key_column, base_column);
     this->lexer_->set_block_indent(sequence_indent);
     this->record_preceding_comments_for_index(0);
@@ -1172,7 +1178,7 @@ class Parser {
       this->lexer_->set_block_indent(sequence_indent);
 
       if (token->column > base_column) {
-        if (token->column < base_column + 2) {
+        if (token->column < base_column + 2) [[unlikely]] {
           throw YAMLParseError{token->line, token->column,
                                "Wrong indentation for sequence entry"};
         }
@@ -1244,7 +1250,7 @@ class Parser {
     const auto mapping_indent{
         start_token.column > 0
             ? static_cast<std::size_t>(start_token.column - 1)
-            : static_cast<std::size_t>(0)};
+            : 0uz};
 
     while (true) {
       this->lexer_->set_block_indent(mapping_indent);
@@ -1279,7 +1285,7 @@ class Parser {
         current_key_line = token.line;
         current_key_column = token.column;
 
-        if (seen_keys.contains(key)) {
+        if (seen_keys.contains(key)) [[unlikely]] {
           throw YAMLDuplicateKeyError{key, token.line, token.column};
         }
         seen_keys.insert(key);
@@ -1323,7 +1329,7 @@ class Parser {
 
         if (key.empty() && next->type == TokenType::Scalar) {
           key = next->value;
-          if (seen_keys.contains(key)) {
+          if (seen_keys.contains(key)) [[unlikely]] {
             throw YAMLDuplicateKeyError{key, next->line, next->column};
           }
           seen_keys.insert(key);
@@ -1361,7 +1367,7 @@ class Parser {
     const std::string anchor_name{token.value};
     const auto iterator{this->anchors_.find(anchor_name)};
 
-    if (iterator == this->anchors_.end()) {
+    if (iterator == this->anchors_.end()) [[unlikely]] {
       throw YAMLUnknownAnchorError{anchor_name, token.line, token.column};
     }
 
@@ -1484,8 +1490,8 @@ class Parser {
                next->type == TokenType::BlockSequenceEntry ||
                next->type == TokenType::Anchor ||
                next->type == TokenType::Tag || next->type == TokenType::Alias) {
-      if (next->type == TokenType::BlockSequenceEntry &&
-          next->line == key_line) {
+      if (next->type == TokenType::BlockSequenceEntry && next->line == key_line)
+          [[unlikely]] {
         throw YAMLParseError{
             next->line, next->column,
             "Block sequence entry on same line as mapping key"};
@@ -1507,7 +1513,7 @@ class Parser {
             next->type == TokenType::Alias)) {
       if (this->document_start_line_ > 0 &&
           first_key_line == this->document_start_line_ &&
-          next->line != this->document_start_line_) {
+          next->line != this->document_start_line_) [[unlikely]] {
         throw YAMLParseError{next->line, next->column,
                              "Block mapping continuation after document "
                              "start line"};
@@ -1531,7 +1537,7 @@ class Parser {
         this->record_key_scalar_style(key, next->scalar_style,
                                       next->quoted_original);
 
-        if (seen_keys.contains(key)) {
+        if (seen_keys.contains(key)) [[unlikely]] {
           throw YAMLDuplicateKeyError{key, next->line, next->column};
         }
         seen_keys.insert(key);
@@ -1594,14 +1600,14 @@ class Parser {
         }
         const std::string alias_name{next->value};
         const auto iterator{this->anchors_.find(alias_name)};
-        if (iterator == this->anchors_.end()) {
+        if (iterator == this->anchors_.end()) [[unlikely]] {
           throw YAMLUnknownAnchorError{alias_name, next->line, next->column};
         }
         key = this->json_to_key_string(iterator->second.value);
         key_line = next->line;
         key_column = next->column;
 
-        if (seen_keys.contains(key)) {
+        if (seen_keys.contains(key)) [[unlikely]] {
           throw YAMLDuplicateKeyError{key, next->line, next->column};
         }
         seen_keys.insert(key);
@@ -1655,12 +1661,12 @@ class Parser {
                                     next->quoted_original);
       this->record_preceding_comments_for_key(key);
 
-      if (next->multiline) {
+      if (next->multiline) [[unlikely]] {
         throw YAMLParseError{next->line, next->column,
                              "Multi-line implicit mapping key"};
       }
 
-      if (seen_keys.contains(key)) {
+      if (seen_keys.contains(key)) [[unlikely]] {
         throw YAMLDuplicateKeyError{key, next->line, next->column};
       }
       seen_keys.insert(key);
@@ -1793,8 +1799,7 @@ class Parser {
     this->pointer_stack_.push_back(index);
     auto indicator_comment{this->lexer_->take_inline_comment()};
     this->roundtrip_->styles[this->pointer_stack_].comment_on_indicator =
-        indicator_comment.has_value() ? std::move(indicator_comment.value())
-                                      : std::string{};
+        std::move(indicator_comment).value_or(std::string{});
     this->pointer_stack_.pop_back();
   }
 
diff --git a/vendor/core/src/core/yaml/stringify.h b/vendor/core/src/core/yaml/stringify.h
index d7734f85e..ecf391e71 100644
--- a/vendor/core/src/core/yaml/stringify.h
+++ b/vendor/core/src/core/yaml/stringify.h
@@ -5,14 +5,15 @@
 #include <sourcemeta/core/jsonpointer.h>
 #include <sourcemeta/core/yaml_roundtrip.h>
 
-#include <array>   // std::array
-#include <cassert> // assert
-#include <cmath>   // std::modf
-#include <cstddef> // std::size_t
-#include <iomanip> // std::setprecision
-#include <ios>     // std::noshowpoint, std::fixed
-#include <ostream> // std::basic_ostream
-#include <string>  // std::to_string
+#include <array>    // std::array
+#include <cassert>  // assert
+#include <charconv> // std::to_chars
+#include <cmath>    // std::modf
+#include <cstddef>  // std::size_t
+#include <iomanip>  // std::setprecision
+#include <ios>      // std::noshowpoint, std::fixed
+#include <ostream>  // std::basic_ostream
+#include <string>   // std::string
 
 namespace sourcemeta::core::yaml {
 
@@ -380,8 +381,11 @@ inline auto write_inline_value(OutputStream &stream, const JSON &value,
       }
       break;
     case JSON::Type::Integer: {
-      const auto string{std::to_string(value.to_integer())};
-      stream.write(string.c_str(), static_cast<std::streamsize>(string.size()));
+      std::array<char, 20> buffer{};
+      const auto [end_pointer, error_code] = std::to_chars(
+          buffer.data(), buffer.data() + buffer.size(), value.to_integer());
+      stream.write(buffer.data(),
+                   static_cast<std::streamsize>(end_pointer - buffer.data()));
     } break;
     case JSON::Type::Real: {
       const auto real{value.to_real()};
diff --git a/vendor/core/src/extension/alterschema/CMakeLists.txt b/vendor/core/src/extension/alterschema/CMakeLists.txt
index 3d3c88df9..43353c9fb 100644
--- a/vendor/core/src/extension/alterschema/CMakeLists.txt
+++ b/vendor/core/src/extension/alterschema/CMakeLists.txt
@@ -82,6 +82,8 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema
     linter/duplicate_examples.h
     linter/enum_to_const.h
     linter/equal_numeric_bounds_to_const.h
+    linter/forbid_empty_enum.h
+    linter/invalid_external_ref.h
     linter/items_array_default.h
     linter/items_schema_default.h
     linter/multiple_of_default.h
diff --git a/vendor/core/src/extension/alterschema/alterschema.cc b/vendor/core/src/extension/alterschema/alterschema.cc
index be4bf3ba9..31be5c343 100644
--- a/vendor/core/src/extension/alterschema/alterschema.cc
+++ b/vendor/core/src/extension/alterschema/alterschema.cc
@@ -5,9 +5,10 @@
 #include <algorithm>     // std::sort, std::unique
 #include <cmath>         // std::floor
 #include <iterator>      // std::back_inserter
+#include <memory>        // std::unique_ptr, std::make_unique
 #include <unordered_map> // std::unordered_map
 #include <unordered_set> // std::unordered_set
-#include <utility>       // std::move
+#include <utility>       // std::move, std::to_underlying
 namespace sourcemeta::core {
 
 template <typename... Args>
@@ -110,6 +111,8 @@ inline auto APPLIES_TO_POINTERS(std::vector<Pointer> &&keywords)
 #include "linter/duplicate_examples.h"
 #include "linter/enum_to_const.h"
 #include "linter/equal_numeric_bounds_to_const.h"
+#include "linter/forbid_empty_enum.h"
+#include "linter/invalid_external_ref.h"
 #include "linter/items_array_default.h"
 #include "linter/items_schema_default.h"
 #include "linter/multiple_of_default.h"
@@ -226,6 +229,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) -> void {
     bundle.add<UnsatisfiableMaxContains>();
     bundle.add<UnsatisfiableMinProperties>();
     bundle.add<EnumToConst>();
+    bundle.add<ForbidEmptyEnum>();
     bundle.add<TopLevelTitle>();
     bundle.add<TopLevelDescription>();
     bundle.add<TopLevelExamples>();
@@ -237,6 +241,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) -> void {
     bundle.add<CommentTrim>();
     bundle.add<DuplicateExamples>();
     bundle.add<SimplePropertiesIdentifiers>();
+    bundle.add<InvalidExternalRef>();
   }
 
   bundle.add<UnnecessaryAllOfRefWrapperModern>();
diff --git a/vendor/core/src/extension/alterschema/common/const_with_type.h b/vendor/core/src/extension/alterschema/common/const_with_type.h
index 820f5ae6f..a853f28b6 100644
--- a/vendor/core/src/extension/alterschema/common/const_with_type.h
+++ b/vendor/core/src/extension/alterschema/common/const_with_type.h
@@ -26,8 +26,8 @@ class ConstWithType final : public SchemaTransformRule {
                      schema.defines("const"));
 
     const auto current_types{parse_schema_type(schema.at("type"))};
-    ONLY_CONTINUE_IF(current_types.test(
-        static_cast<std::size_t>(schema.at("const").type())));
+    ONLY_CONTINUE_IF(
+        current_types.test(std::to_underlying(schema.at("const").type())));
     return APPLIES_TO_KEYWORDS("const", "type");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/enum_with_type.h b/vendor/core/src/extension/alterschema/common/enum_with_type.h
index c2a8949c6..941b0fb98 100644
--- a/vendor/core/src/extension/alterschema/common/enum_with_type.h
+++ b/vendor/core/src/extension/alterschema/common/enum_with_type.h
@@ -32,7 +32,7 @@ class EnumWithType final : public SchemaTransformRule {
     const auto current_types{parse_schema_type(schema.at("type"))};
     ONLY_CONTINUE_IF(std::ranges::all_of(
         schema.at("enum").as_array(), [&current_types](const auto &item) {
-          return current_types.test(static_cast<std::size_t>(item.type()));
+          return current_types.test(std::to_underlying(item.type()));
         }));
 
     return APPLIES_TO_KEYWORDS("enum", "type");
diff --git a/vendor/core/src/extension/alterschema/common/non_applicable_enum_validation_keywords.h b/vendor/core/src/extension/alterschema/common/non_applicable_enum_validation_keywords.h
index 593037003..a56c24015 100644
--- a/vendor/core/src/extension/alterschema/common/non_applicable_enum_validation_keywords.h
+++ b/vendor/core/src/extension/alterschema/common/non_applicable_enum_validation_keywords.h
@@ -33,7 +33,7 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule {
 
     sourcemeta::core::JSON::TypeSet enum_types;
     for (const auto &value : schema.at("enum").as_array()) {
-      enum_types.set(static_cast<std::size_t>(value.type()));
+      enum_types.set(std::to_underlying(value.type()));
     }
 
     ONLY_CONTINUE_IF(enum_types.any());
diff --git a/vendor/core/src/extension/alterschema/common/non_applicable_type_specific_keywords.h b/vendor/core/src/extension/alterschema/common/non_applicable_type_specific_keywords.h
index db188c271..a727a7de2 100644
--- a/vendor/core/src/extension/alterschema/common/non_applicable_type_specific_keywords.h
+++ b/vendor/core/src/extension/alterschema/common/non_applicable_type_specific_keywords.h
@@ -46,7 +46,7 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
              Vocabularies::Known::JSON_Schema_Draft_1}) &&
         schema.defines("enum") && schema.at("enum").is_array()) {
       for (const auto &entry : schema.at("enum").as_array()) {
-        current_types.set(static_cast<std::size_t>(entry.type()));
+        current_types.set(std::to_underlying(entry.type()));
       }
     }
 
@@ -56,7 +56,7 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
              Vocabularies::Known::JSON_Schema_Draft_7,
              Vocabularies::Known::JSON_Schema_Draft_6}) &&
         schema.defines("const")) {
-      current_types.set(static_cast<std::size_t>(schema.at("const").type()));
+      current_types.set(std::to_underlying(schema.at("const").type()));
     }
 
     // This means that the schema has no explicit type constraints,
diff --git a/vendor/core/src/extension/alterschema/common/oneof_to_anyof_disjoint_types.h b/vendor/core/src/extension/alterschema/common/oneof_to_anyof_disjoint_types.h
index d9a16bc58..1d31dbd28 100644
--- a/vendor/core/src/extension/alterschema/common/oneof_to_anyof_disjoint_types.h
+++ b/vendor/core/src/extension/alterschema/common/oneof_to_anyof_disjoint_types.h
@@ -60,12 +60,12 @@ class OneOfToAnyOfDisjointTypes final : public SchemaTransformRule {
         type_sets.push_back(parse_schema_type(branch.at("type")));
       } else if (has_const && !has_enum) {
         JSON::TypeSet branch_types;
-        branch_types.set(static_cast<std::size_t>(branch.at("const").type()));
+        branch_types.set(std::to_underlying(branch.at("const").type()));
         type_sets.push_back(branch_types);
       } else if (has_enum && !has_const) {
         JSON::TypeSet branch_types;
         for (const auto &item : branch.at("enum").as_array()) {
-          branch_types.set(static_cast<std::size_t>(item.type()));
+          branch_types.set(std::to_underlying(item.type()));
         }
         type_sets.push_back(branch_types);
       } else {
diff --git a/vendor/core/src/extension/alterschema/linter/forbid_empty_enum.h b/vendor/core/src/extension/alterschema/linter/forbid_empty_enum.h
new file mode 100644
index 000000000..279d20f55
--- /dev/null
+++ b/vendor/core/src/extension/alterschema/linter/forbid_empty_enum.h
@@ -0,0 +1,36 @@
+class ForbidEmptyEnum final : public SchemaTransformRule {
+public:
+  using mutates = std::true_type;
+  using reframe_after_transform = std::true_type;
+  ForbidEmptyEnum()
+      : SchemaTransformRule{"forbid_empty_enum",
+                            "An empty `enum` validates nothing and is "
+                            "unsatisfiable"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::Vocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &frame,
+            const sourcemeta::core::SchemaFrame::Location &location,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &) const
+      -> sourcemeta::core::SchemaTransformRule::Result override {
+    ONLY_CONTINUE_IF(vocabularies.contains_any(
+                         {Vocabularies::Known::JSON_Schema_2020_12_Validation,
+                          Vocabularies::Known::JSON_Schema_2019_09_Validation,
+                          Vocabularies::Known::JSON_Schema_Draft_7,
+                          Vocabularies::Known::JSON_Schema_Draft_6,
+                          Vocabularies::Known::JSON_Schema_Draft_4}) &&
+                     schema.is_object() && !schema.defines("not") &&
+                     schema.defines("enum") && schema.at("enum").is_array() &&
+                     schema.at("enum").empty());
+    ONLY_CONTINUE_IF(!frame.has_references_through(location.pointer));
+    return APPLIES_TO_KEYWORDS("enum");
+  }
+
+  auto transform(JSON &schema, const Result &) const -> void override {
+    schema.at("enum").into(JSON::make_object());
+    schema.rename("enum", "not");
+  }
+};
diff --git a/vendor/core/src/extension/alterschema/linter/invalid_external_ref.h b/vendor/core/src/extension/alterschema/linter/invalid_external_ref.h
new file mode 100644
index 000000000..d0dbcf504
--- /dev/null
+++ b/vendor/core/src/extension/alterschema/linter/invalid_external_ref.h
@@ -0,0 +1,112 @@
+class InvalidExternalRef final : public SchemaTransformRule {
+public:
+  using mutates = std::false_type;
+  using reframe_after_transform = std::false_type;
+  InvalidExternalRef()
+      : SchemaTransformRule{
+            "invalid_external_ref",
+            "External references must point to schemas that can be "
+            "resolved"} {};
+
+  [[nodiscard]] auto
+  condition(const JSON &schema, const JSON &, const Vocabularies &vocabularies,
+            const SchemaFrame &frame, const SchemaFrame::Location &location,
+            const SchemaWalker &walker, const SchemaResolver &resolver) const
+      -> SchemaTransformRule::Result override {
+    ONLY_CONTINUE_IF(!frame.standalone());
+    ONLY_CONTINUE_IF(vocabularies.contains_any(
+        {Vocabularies::Known::JSON_Schema_2020_12_Core,
+         Vocabularies::Known::JSON_Schema_2019_09_Core,
+         Vocabularies::Known::JSON_Schema_Draft_7,
+         Vocabularies::Known::JSON_Schema_Draft_6,
+         Vocabularies::Known::JSON_Schema_Draft_4,
+         Vocabularies::Known::JSON_Schema_Draft_3}));
+    ONLY_CONTINUE_IF(schema.is_object() && schema.defines(KEYWORD) &&
+                     schema.at(KEYWORD).is_string());
+
+    auto keyword_pointer{location.pointer};
+    keyword_pointer.push_back(std::cref(KEYWORD));
+    const auto reference_entry{
+        frame.reference(SchemaReferenceType::Static, keyword_pointer)};
+    ONLY_CONTINUE_IF(reference_entry.has_value());
+
+    // If the destination exists in the frame, it is an internal reference
+    ONLY_CONTINUE_IF(
+        !frame.traverse(reference_entry->get().destination).has_value());
+
+    const auto &reference_base{reference_entry->get().base};
+
+    // Empty base with unresolvable destination is a local reference problem
+    ONLY_CONTINUE_IF(!reference_base.empty());
+
+    // Known official metaschemas are always resolvable
+    ONLY_CONTINUE_IF(!is_known_schema(reference_base));
+
+    // If the base exists in the frame, the reference is internal (e.g. an
+    // embedded $id). A bad fragment on an internal base is handled by the
+    // unknown_local_ref rule instead
+    ONLY_CONTINUE_IF(!frame.traverse(reference_base).has_value());
+
+    const auto &has_fragment{reference_entry->get().fragment.has_value()};
+    const JSON::String base_key{reference_base};
+
+    // Check the resolver cache to avoid redundant lookups
+    const auto cached{this->resolver_cache_.find(base_key)};
+    if (cached != this->resolver_cache_.end()) {
+      if (!cached->second.has_value()) {
+        return APPLIES_TO_KEYWORDS(KEYWORD);
+      }
+
+      if (has_fragment) {
+        return this->is_fragment_invalid(reference_entry->get(), cached->second,
+                                         base_key, walker, resolver, location)
+                   ? APPLIES_TO_KEYWORDS(KEYWORD)
+                   : false;
+      }
+
+      return false;
+    }
+
+    auto remote{resolver(reference_base)};
+    const auto &[entry,
+                 _]{this->resolver_cache_.emplace(base_key, std::move(remote))};
+    if (!entry->second.has_value()) {
+      return APPLIES_TO_KEYWORDS(KEYWORD);
+    }
+
+    if (has_fragment) {
+      return this->is_fragment_invalid(reference_entry->get(), entry->second,
+                                       base_key, walker, resolver, location)
+                 ? APPLIES_TO_KEYWORDS(KEYWORD)
+                 : false;
+    }
+
+    return false;
+  }
+
+private:
+  static inline const std::string KEYWORD{"$ref"};
+  mutable std::unordered_map<JSON::String, std::optional<JSON>> resolver_cache_;
+  mutable std::unordered_map<JSON::String, std::unique_ptr<SchemaFrame>>
+      frame_cache_;
+
+  [[nodiscard]] auto
+  is_fragment_invalid(const SchemaFrame::ReferencesEntry &reference_entry,
+                      const std::optional<JSON> &remote,
+                      const JSON::String &base_key, const SchemaWalker &walker,
+                      const SchemaResolver &resolver,
+                      const SchemaFrame::Location &location) const -> bool {
+    auto frame_iterator{this->frame_cache_.find(base_key)};
+    if (frame_iterator == this->frame_cache_.end()) {
+      auto remote_frame{
+          std::make_unique<SchemaFrame>(SchemaFrame::Mode::Locations)};
+      remote_frame->analyse(remote.value(), walker, resolver, location.dialect,
+                            base_key);
+      frame_iterator =
+          this->frame_cache_.emplace(base_key, std::move(remote_frame)).first;
+    }
+
+    return !frame_iterator->second->traverse(reference_entry.destination)
+                .has_value();
+  }
+};
diff --git a/vendor/core/src/lang/io/io_temporary.cc b/vendor/core/src/lang/io/io_temporary.cc
index 66f67b01a..44384beb0 100644
--- a/vendor/core/src/lang/io/io_temporary.cc
+++ b/vendor/core/src/lang/io/io_temporary.cc
@@ -17,8 +17,8 @@ namespace sourcemeta::core {
 TemporaryDirectory::TemporaryDirectory(const std::filesystem::path &parent,
                                        const std::string_view prefix) {
   assert(!prefix.empty());
-  assert(prefix.find('/') == std::string_view::npos);
-  assert(prefix.find('\\') == std::string_view::npos);
+  assert(!prefix.contains('/'));
+  assert(!prefix.contains('\\'));
   if (std::filesystem::exists(parent) &&
       !std::filesystem::is_directory(parent)) {
     throw std::filesystem::filesystem_error{
diff --git a/vendor/core/src/lang/numeric/parse.cc b/vendor/core/src/lang/numeric/parse.cc
index 7b3cc1a71..d5880849c 100644
--- a/vendor/core/src/lang/numeric/parse.cc
+++ b/vendor/core/src/lang/numeric/parse.cc
@@ -1,6 +1,8 @@
 #include <sourcemeta/core/numeric_parse.h>
 
-#include <stdexcept> // std::invalid_argument, std::out_of_range
+#include <charconv>     // std::from_chars
+#include <stdexcept>    // std::invalid_argument, std::out_of_range
+#include <system_error> // std::errc
 
 namespace sourcemeta::core {
 
@@ -21,13 +23,14 @@ auto to_int64_t(const std::string &input) noexcept
 
 auto to_int64_t(const std::string &input, const int base) noexcept
     -> std::optional<std::int64_t> {
-  try {
-    return static_cast<std::int64_t>(std::stoll(input, nullptr, base));
-  } catch (const std::invalid_argument &) {
-    return std::nullopt;
-  } catch (const std::out_of_range &) {
+  std::int64_t value{};
+  const auto result =
+      std::from_chars(input.data(), input.data() + input.size(), value, base);
+  if (result.ec != std::errc{}) {
     return std::nullopt;
   }
+
+  return value;
 }
 
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h b/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
index 873dcf7f9..e9dfba3c6 100644
--- a/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
+++ b/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
@@ -76,8 +76,7 @@ auto parallel_for_each(
     Iterator first, Iterator last, Callback &&callback,
     const std::size_t parallelism = std::thread::hardware_concurrency(),
     const std::size_t stack_size_bytes = 0) -> void {
-  const auto effective_parallelism{
-      std::max(parallelism, static_cast<std::size_t>(1))};
+  const auto effective_parallelism{std::max(parallelism, 1uz)};
 
   // Empty list
   if (first == last) {
@@ -144,6 +143,8 @@ auto parallel_for_each(
     }
   };
 
+  // TODO: Replace std::function with std::move_only_function once
+  // Apple Clang ships libc++ 19+ (__cpp_lib_move_only_function)
 #if defined(_WIN32)
   for (std::size_t index = 0; index < effective_parallelism; ++index) {
     auto *heap_function = new std::function<void()>(worker_callable);
diff --git a/vendor/core/src/lang/process/spawn.cc b/vendor/core/src/lang/process/spawn.cc
index d5a545b8d..f180ad5c4 100644
--- a/vendor/core/src/lang/process/spawn.cc
+++ b/vendor/core/src/lang/process/spawn.cc
@@ -42,7 +42,7 @@ auto spawn(const std::string &program,
     command_line << " ";
     // Quote arguments that contain spaces
     const std::string arg_str{argument};
-    if (arg_str.find(' ') != std::string::npos) {
+    if (arg_str.contains(' ')) {
       command_line << "\"" << arg_str << "\"";
     } else {
       command_line << arg_str;