diff --git a/DEPENDENCIES b/DEPENDENCIES
index c2a99e2c..e7535cac 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -1,6 +1,6 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
 uwebsockets https://github.com/uNetworking/uWebSockets v20.74.0
-core https://github.com/sourcemeta/core d78c8611797712b29c98b8e44d802baff930bc47
+core https://github.com/sourcemeta/core 02a6f9f32499622162ac78d49da33f30e31fae93
 blaze https://github.com/sourcemeta/blaze 8dba65f8aebfe1ac976168b76e01c20dd406c517
 jsonbinpack https://github.com/sourcemeta/jsonbinpack 8fae212dc7ec02af4bb0cd4e7fccd42a2471f1c1
 hydra https://github.com/sourcemeta/hydra af9f2c54709d620872ead0c3f8f683c15a0fa702
diff --git a/vendor/core/src/core/jsonschema/bundle.cc b/vendor/core/src/core/jsonschema/bundle.cc
index c668d664..cb449220 100644
--- a/vendor/core/src/core/jsonschema/bundle.cc
+++ b/vendor/core/src/core/jsonschema/bundle.cc
@@ -3,6 +3,7 @@
 #include <cassert>       // assert
 #include <functional>    // std::reference_wrapper
 #include <sstream>       // std::ostringstream
+#include <string_view>   // std::string_view
 #include <tuple>         // std::tuple
 #include <unordered_set> // std::unordered_set
 #include <utility>       // std::move
@@ -140,6 +141,7 @@ auto bundle_schema(sourcemeta::core::JSON &root,
                    const std::optional<std::string> &default_dialect,
                    const std::optional<std::string> &default_id,
                    const sourcemeta::core::SchemaFrame::Paths &paths,
+                   const std::unordered_set<std::string_view> &exclusions,
                    const std::size_t depth = 0) -> void {
   // Keep in mind that the resulting frame does miss some information. For
   // example, when we recurse to framing embedded schemas, we will frame them
@@ -185,6 +187,11 @@ auto bundle_schema(sourcemeta::core::JSON &root,
 
     assert(reference.base.has_value());
     const auto &identifier{reference.base.value()};
+
+    if (exclusions.contains(identifier)) {
+      continue;
+    }
+
     auto remote{resolver(identifier)};
     if (!remote.has_value()) {
       if (frame.traverse(identifier).has_value()) {
@@ -219,7 +226,7 @@ auto bundle_schema(sourcemeta::core::JSON &root,
     }
 
     bundle_schema(root, container, remote.value(), frame, walker, resolver,
-                  default_dialect, identifier, paths, depth + 1);
+                  default_dialect, identifier, paths, exclusions, depth + 1);
     embed_schema(root, container, identifier, std::move(remote).value());
   }
 }
@@ -246,14 +253,15 @@ auto bundle(JSON &schema, const SchemaWalker &walker,
             const std::optional<std::string> &default_dialect,
             const std::optional<std::string> &default_id,
             const std::optional<Pointer> &default_container,
-            const SchemaFrame::Paths &paths) -> void {
+            const SchemaFrame::Paths &paths,
+            const std::unordered_set<std::string_view> &exclusions) -> void {
   SchemaFrame frame{SchemaFrame::Mode::References};
 
   if (default_container.has_value()) {
     // This is undefined behavior
     assert(!default_container.value().empty());
     bundle_schema(schema, default_container.value(), schema, frame, walker,
-                  resolver, default_dialect, default_id, paths);
+                  resolver, default_dialect, default_id, paths, exclusions);
     return;
   }
 
@@ -273,7 +281,7 @@ auto bundle(JSON &schema, const SchemaWalker &walker,
       vocabularies.contains(
           sourcemeta::core::Vocabularies::Known::JSON_Schema_2019_09_Core)) {
     bundle_schema(schema, {"$defs"}, schema, frame, walker, resolver,
-                  default_dialect, default_id, paths);
+                  default_dialect, default_id, paths, exclusions);
     return;
   } else if (
       vocabularies.contains(
@@ -305,7 +313,7 @@ auto bundle(JSON &schema, const SchemaWalker &walker,
     }
 
     bundle_schema(schema, {"definitions"}, schema, frame, walker, resolver,
-                  default_dialect, default_id, paths);
+                  default_dialect, default_id, paths, exclusions);
     return;
   } else if (
       vocabularies.contains(
@@ -341,10 +349,11 @@ auto bundle(const JSON &schema, const SchemaWalker &walker,
             const std::optional<std::string> &default_dialect,
             const std::optional<std::string> &default_id,
             const std::optional<Pointer> &default_container,
-            const SchemaFrame::Paths &paths) -> JSON {
+            const SchemaFrame::Paths &paths,
+            const std::unordered_set<std::string_view> &exclusions) -> JSON {
   JSON copy = schema;
   bundle(copy, walker, resolver, default_dialect, default_id, default_container,
-         paths);
+         paths, exclusions);
   return copy;
 }
 
diff --git a/vendor/core/src/core/jsonschema/frame.cc b/vendor/core/src/core/jsonschema/frame.cc
index 9cfb1af5..1b8681a7 100644
--- a/vendor/core/src/core/jsonschema/frame.cc
+++ b/vendor/core/src/core/jsonschema/frame.cc
@@ -987,13 +987,7 @@ auto SchemaFrame::dereference(const Location &location,
   return {SchemaReferenceType::Static, destination->second};
 }
 
-auto SchemaFrame::references_to(const Pointer &pointer) const -> std::vector<
-    std::reference_wrapper<const typename References::value_type>> {
-  std::vector<std::reference_wrapper<const typename References::value_type>>
-      result;
-
-  // TODO: This is currently very slow, as we need to loop on every reference
-  // to brute force whether it points to the desired entry or not
+auto SchemaFrame::has_references_to(const Pointer &pointer) const -> bool {
   for (const auto &reference : this->references_) {
     assert(!reference.first.second.empty());
     assert(reference.first.second.back().is_property());
@@ -1003,7 +997,7 @@ auto SchemaFrame::references_to(const Pointer &pointer) const -> std::vector<
           {reference.first.first, reference.second.destination})};
       if (match != this->locations_.cend() &&
           match->second.pointer == pointer) {
-        result.emplace_back(reference);
+        return true;
       }
     } else {
       for (const auto &location : this->locations_) {
@@ -1013,14 +1007,44 @@ auto SchemaFrame::references_to(const Pointer &pointer) const -> std::vector<
           if (!reference.second.fragment.has_value() ||
               URI{location.first.second}.fragment().value_or("") ==
                   reference.second.fragment.value()) {
-            result.emplace_back(reference);
+            return true;
           }
         }
       }
     }
   }
 
-  return result;
+  return false;
+}
+
+auto SchemaFrame::has_references_through(const Pointer &pointer) const -> bool {
+  for (const auto &reference : this->references_) {
+    assert(!reference.first.second.empty());
+    assert(reference.first.second.back().is_property());
+
+    if (reference.first.first == SchemaReferenceType::Static) {
+      const auto match{this->locations_.find(
+          {reference.first.first, reference.second.destination})};
+      if (match != this->locations_.cend() &&
+          match->second.pointer.starts_with(pointer)) {
+        return true;
+      }
+    } else {
+      for (const auto &location : this->locations_) {
+        if (location.second.type == LocationType::Anchor &&
+            location.first.first == SchemaReferenceType::Dynamic &&
+            location.second.pointer.starts_with(pointer)) {
+          if (!reference.second.fragment.has_value() ||
+              URI{location.first.second}.fragment().value_or("") ==
+                  reference.second.fragment.value()) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return false;
 }
 
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_bundle.h b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_bundle.h
index fedff5b6..80de23dd 100644
--- a/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_bundle.h
+++ b/vendor/core/src/core/jsonschema/include/sourcemeta/core/jsonschema_bundle.h
@@ -13,8 +13,10 @@
 #include <sourcemeta/core/jsonschema_types.h>
 // NOLINTEND(misc-include-cleaner)
 
-#include <functional> // std::function
-#include <optional>   // std::optional, std::nullopt
+#include <functional>    // std::function
+#include <optional>      // std::optional, std::nullopt
+#include <string_view>   // std::string_view
+#include <unordered_set> // std::unordered_set
 
 namespace sourcemeta::core {
 
@@ -129,7 +131,9 @@ auto bundle(JSON &schema, const SchemaWalker &walker,
             const std::optional<std::string> &default_dialect = std::nullopt,
             const std::optional<std::string> &default_id = std::nullopt,
             const std::optional<Pointer> &default_container = std::nullopt,
-            const SchemaFrame::Paths &paths = {empty_pointer}) -> void;
+            const SchemaFrame::Paths &paths = {empty_pointer},
+            const std::unordered_set<std::string_view> &exclusions = {})
+    -> void;
 
 /// @ingroup jsonschema
 ///
@@ -188,7 +192,9 @@ auto bundle(const JSON &schema, const SchemaWalker &walker,
             const std::optional<std::string> &default_dialect = std::nullopt,
             const std::optional<std::string> &default_id = std::nullopt,
             const std::optional<Pointer> &default_container = std::nullopt,
-            const SchemaFrame::Paths &paths = {empty_pointer}) -> JSON;
+            const SchemaFrame::Paths &paths = {empty_pointer},
+            const std::unordered_set<std::string_view> &exclusions = {})
+    -> JSON;
 
 } // namespace sourcemeta::core
 
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 ed2ac645..3613b807 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
@@ -233,9 +233,12 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
       -> std::pair<SchemaReferenceType,
                    std::optional<std::reference_wrapper<const Location>>>;
 
-  /// Find all references to a given location pointer
-  [[nodiscard]] auto references_to(const Pointer &pointer) const -> std::vector<
-      std::reference_wrapper<const typename References::value_type>>;
+  /// Check if there are any references to a given location pointer
+  [[nodiscard]] auto has_references_to(const Pointer &pointer) const -> bool;
+
+  /// Check if there are any references that go through a given location pointer
+  [[nodiscard]] auto has_references_through(const Pointer &pointer) const
+      -> bool;
 
 private:
   Mode mode_;
diff --git a/vendor/core/src/extension/alterschema/common/content_schema_without_media_type.h b/vendor/core/src/extension/alterschema/common/content_schema_without_media_type.h
index f6d627b2..12a9d40e 100644
--- a/vendor/core/src/extension/alterschema/common/content_schema_without_media_type.h
+++ b/vendor/core/src/extension/alterschema/common/content_schema_without_media_type.h
@@ -10,8 +10,8 @@ class ContentSchemaWithoutMediaType final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -20,6 +20,8 @@ class ContentSchemaWithoutMediaType final : public SchemaTransformRule {
                           Vocabularies::Known::JSON_Schema_2019_09_Content}) &&
                      schema.is_object() && schema.defines("contentSchema") &&
                      !schema.defines("contentMediaType"));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"contentSchema"})));
     return APPLIES_TO_KEYWORDS("contentSchema");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/else_empty.h b/vendor/core/src/extension/alterschema/common/else_empty.h
index 1dfb6e7b..da3d6f6d 100644
--- a/vendor/core/src/extension/alterschema/common/else_empty.h
+++ b/vendor/core/src/extension/alterschema/common/else_empty.h
@@ -7,7 +7,7 @@ class ElseEmpty final : public SchemaTransformRule {
 
   [[nodiscard]] auto
   condition(const JSON &schema, const JSON &, const Vocabularies &vocabularies,
-            const SchemaFrame &, const SchemaFrame::Location &,
+            const SchemaFrame &frame, const SchemaFrame::Location &location,
             const SchemaWalker &, const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
@@ -20,6 +20,8 @@ class ElseEmpty final : public SchemaTransformRule {
         (schema.at("else").is_object() ||
          (!schema.defines("if") ||
           !(schema.at("if").is_boolean() && schema.at("if").to_boolean()))));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"else"})));
     return APPLIES_TO_KEYWORDS("else");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/else_without_if.h b/vendor/core/src/extension/alterschema/common/else_without_if.h
index da3349c5..d5c50a6f 100644
--- a/vendor/core/src/extension/alterschema/common/else_without_if.h
+++ b/vendor/core/src/extension/alterschema/common/else_without_if.h
@@ -9,8 +9,8 @@ class ElseWithoutIf final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -20,6 +20,8 @@ class ElseWithoutIf final : public SchemaTransformRule {
                           Vocabularies::Known::JSON_Schema_Draft_7}) &&
                      schema.is_object() && schema.defines("else") &&
                      !schema.defines("if"));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"else"})));
     return APPLIES_TO_KEYWORDS("else");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/if_without_then_else.h b/vendor/core/src/extension/alterschema/common/if_without_then_else.h
index a767054e..6ca4e5df 100644
--- a/vendor/core/src/extension/alterschema/common/if_without_then_else.h
+++ b/vendor/core/src/extension/alterschema/common/if_without_then_else.h
@@ -10,8 +10,8 @@ class IfWithoutThenElse final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -21,6 +21,8 @@ class IfWithoutThenElse final : public SchemaTransformRule {
                           Vocabularies::Known::JSON_Schema_Draft_7}) &&
                      schema.is_object() && schema.defines("if") &&
                      !schema.defines("then") && !schema.defines("else"));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"if"})));
     return APPLIES_TO_KEYWORDS("if");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/non_applicable_additional_items.h b/vendor/core/src/extension/alterschema/common/non_applicable_additional_items.h
index 84317b21..ffe987be 100644
--- a/vendor/core/src/extension/alterschema/common/non_applicable_additional_items.h
+++ b/vendor/core/src/extension/alterschema/common/non_applicable_additional_items.h
@@ -10,8 +10,8 @@ class NonApplicableAdditionalItems final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -23,6 +23,9 @@ class NonApplicableAdditionalItems final : public SchemaTransformRule {
                           Vocabularies::Known::JSON_Schema_Draft_3}) &&
                      schema.is_object() && schema.defines("additionalItems"));
 
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"additionalItems"})));
+
     if (schema.defines("items") && is_schema(schema.at("items"))) {
       return APPLIES_TO_KEYWORDS("additionalItems", "items");
     } else if (!schema.defines("items")) {
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 4d1445ac..82ed87f5 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
@@ -9,8 +9,8 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaFrame &frame,
+            const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
@@ -73,6 +73,12 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
       // If none of the types that the keyword applies to is a valid
       // type for the current schema, then by definition we can remove it
       if ((metadata.instances & current_types).none()) {
+        // Skip keywords that have references pointing to them
+        if (frame.has_references_through(
+                location.relative_pointer.concat({entry.first}))) {
+          continue;
+        }
+
         positions.push_back(Pointer{entry.first});
       }
     }
diff --git a/vendor/core/src/extension/alterschema/common/not_false.h b/vendor/core/src/extension/alterschema/common/not_false.h
index 5c021943..5011962a 100644
--- a/vendor/core/src/extension/alterschema/common/not_false.h
+++ b/vendor/core/src/extension/alterschema/common/not_false.h
@@ -8,7 +8,7 @@ class NotFalse final : public SchemaTransformRule {
 
   [[nodiscard]] auto
   condition(const JSON &schema, const JSON &, const Vocabularies &vocabularies,
-            const SchemaFrame &, const SchemaFrame::Location &,
+            const SchemaFrame &frame, const SchemaFrame::Location &location,
             const SchemaWalker &, const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
@@ -20,6 +20,8 @@ class NotFalse final : public SchemaTransformRule {
                      schema.is_object() && schema.defines("not") &&
                      schema.at("not").is_boolean() &&
                      !schema.at("not").to_boolean());
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"not"})));
     return APPLIES_TO_KEYWORDS("not");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/then_empty.h b/vendor/core/src/extension/alterschema/common/then_empty.h
index 77baf134..eb9de1c0 100644
--- a/vendor/core/src/extension/alterschema/common/then_empty.h
+++ b/vendor/core/src/extension/alterschema/common/then_empty.h
@@ -7,7 +7,7 @@ class ThenEmpty final : public SchemaTransformRule {
 
   [[nodiscard]] auto
   condition(const JSON &schema, const JSON &, const Vocabularies &vocabularies,
-            const SchemaFrame &, const SchemaFrame::Location &,
+            const SchemaFrame &frame, const SchemaFrame::Location &location,
             const SchemaWalker &, const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
@@ -20,6 +20,8 @@ class ThenEmpty final : public SchemaTransformRule {
         (schema.at("then").is_object() ||
          (!schema.defines("if") ||
           !(schema.at("if").is_boolean() && schema.at("if").to_boolean()))));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"then"})));
     return APPLIES_TO_KEYWORDS("then");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/then_without_if.h b/vendor/core/src/extension/alterschema/common/then_without_if.h
index b1e3c5ab..3ca02be4 100644
--- a/vendor/core/src/extension/alterschema/common/then_without_if.h
+++ b/vendor/core/src/extension/alterschema/common/then_without_if.h
@@ -9,8 +9,8 @@ class ThenWithoutIf final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -20,6 +20,8 @@ class ThenWithoutIf final : public SchemaTransformRule {
                           Vocabularies::Known::JSON_Schema_Draft_7}) &&
                      schema.is_object() && schema.defines("then") &&
                      !schema.defines("if"));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"then"})));
     return APPLIES_TO_KEYWORDS("then");
   }
 
diff --git a/vendor/core/src/extension/alterschema/common/unnecessary_allof_wrapper.h b/vendor/core/src/extension/alterschema/common/unnecessary_allof_wrapper.h
index 4541a864..e6c6dcbe 100644
--- a/vendor/core/src/extension/alterschema/common/unnecessary_allof_wrapper.h
+++ b/vendor/core/src/extension/alterschema/common/unnecessary_allof_wrapper.h
@@ -54,7 +54,7 @@ class UnnecessaryAllOfWrapper final : public SchemaTransformRule {
       // Skip entries that have direct references pointing to them
       const auto entry_pointer{
           location.relative_pointer.concat({"allOf", index - 1})};
-      if (!frame.references_to(entry_pointer).empty()) {
+      if (frame.has_references_to(entry_pointer)) {
         continue;
       }
 
diff --git a/vendor/core/src/extension/alterschema/linter/additional_properties_default.h b/vendor/core/src/extension/alterschema/linter/additional_properties_default.h
index ce81205f..b02737df 100644
--- a/vendor/core/src/extension/alterschema/linter/additional_properties_default.h
+++ b/vendor/core/src/extension/alterschema/linter/additional_properties_default.h
@@ -10,8 +10,8 @@ class AdditionalPropertiesDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -32,6 +32,8 @@ class AdditionalPropertiesDefault final : public SchemaTransformRule {
                        schema.at("additionalProperties").to_boolean()) ||
                       (schema.at("additionalProperties").is_object() &&
                        schema.at("additionalProperties").empty())));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"additionalProperties"})));
     return APPLIES_TO_KEYWORDS("additionalProperties");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/content_schema_default.h b/vendor/core/src/extension/alterschema/linter/content_schema_default.h
index 536acbf7..67585a21 100644
--- a/vendor/core/src/extension/alterschema/linter/content_schema_default.h
+++ b/vendor/core/src/extension/alterschema/linter/content_schema_default.h
@@ -10,8 +10,8 @@ class ContentSchemaDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -23,6 +23,8 @@ class ContentSchemaDefault final : public SchemaTransformRule {
                        schema.at("contentSchema").to_boolean()) ||
                       (schema.at("contentSchema").is_object() &&
                        schema.at("contentSchema").empty())));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"contentSchema"})));
     return APPLIES_TO_KEYWORDS("contentSchema");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/dependencies_default.h b/vendor/core/src/extension/alterschema/linter/dependencies_default.h
index ec5cb10b..0b349a67 100644
--- a/vendor/core/src/extension/alterschema/linter/dependencies_default.h
+++ b/vendor/core/src/extension/alterschema/linter/dependencies_default.h
@@ -10,8 +10,8 @@ class DependenciesDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -23,6 +23,8 @@ class DependenciesDefault final : public SchemaTransformRule {
         schema.is_object() && schema.defines("dependencies") &&
         schema.at("dependencies").is_object() &&
         schema.at("dependencies").empty());
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"dependencies"})));
     return APPLIES_TO_KEYWORDS("dependencies");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/items_schema_default.h b/vendor/core/src/extension/alterschema/linter/items_schema_default.h
index 1425ab79..40afc254 100644
--- a/vendor/core/src/extension/alterschema/linter/items_schema_default.h
+++ b/vendor/core/src/extension/alterschema/linter/items_schema_default.h
@@ -9,8 +9,8 @@ class ItemsSchemaDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -29,6 +29,8 @@ class ItemsSchemaDefault final : public SchemaTransformRule {
         schema.is_object() && schema.defines("items") &&
         ((schema.at("items").is_boolean() && schema.at("items").to_boolean()) ||
          (schema.at("items").is_object() && schema.at("items").empty())));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"items"})));
     return APPLIES_TO_KEYWORDS("items");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/property_names_default.h b/vendor/core/src/extension/alterschema/linter/property_names_default.h
index 0bb4fcc8..899a097d 100644
--- a/vendor/core/src/extension/alterschema/linter/property_names_default.h
+++ b/vendor/core/src/extension/alterschema/linter/property_names_default.h
@@ -10,8 +10,8 @@ class PropertyNamesDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -23,6 +23,8 @@ class PropertyNamesDefault final : public SchemaTransformRule {
                      schema.is_object() && schema.defines("propertyNames") &&
                      schema.at("propertyNames").is_object() &&
                      schema.at("propertyNames").empty());
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"propertyNames"})));
     return APPLIES_TO_KEYWORDS("propertyNames");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/unevaluated_items_default.h b/vendor/core/src/extension/alterschema/linter/unevaluated_items_default.h
index 23bdebc9..82e1dbb9 100644
--- a/vendor/core/src/extension/alterschema/linter/unevaluated_items_default.h
+++ b/vendor/core/src/extension/alterschema/linter/unevaluated_items_default.h
@@ -10,8 +10,8 @@ class UnevaluatedItemsDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -24,6 +24,8 @@ class UnevaluatedItemsDefault final : public SchemaTransformRule {
           schema.at("unevaluatedItems").to_boolean()) ||
          (schema.at("unevaluatedItems").is_object() &&
           schema.at("unevaluatedItems").empty())));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"unevaluatedItems"})));
     return APPLIES_TO_KEYWORDS("unevaluatedItems");
   }
 
diff --git a/vendor/core/src/extension/alterschema/linter/unevaluated_properties_default.h b/vendor/core/src/extension/alterschema/linter/unevaluated_properties_default.h
index b9dc5bf1..8d4db8f2 100644
--- a/vendor/core/src/extension/alterschema/linter/unevaluated_properties_default.h
+++ b/vendor/core/src/extension/alterschema/linter/unevaluated_properties_default.h
@@ -10,8 +10,8 @@ class UnevaluatedPropertiesDefault final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::Vocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            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 {
@@ -24,6 +24,8 @@ class UnevaluatedPropertiesDefault final : public SchemaTransformRule {
           schema.at("unevaluatedProperties").to_boolean()) ||
          (schema.at("unevaluatedProperties").is_object() &&
           schema.at("unevaluatedProperties").empty())));
+    ONLY_CONTINUE_IF(!frame.has_references_through(
+        location.relative_pointer.concat({"unevaluatedProperties"})));
     return APPLIES_TO_KEYWORDS("unevaluatedProperties");
   }