jsi 0.8.2 → 0.9.0

data/lib/jsi/schema.rb

@@ -11,125 +11,50 @@ module JSI
   # The content of an instance which is a JSI::Schema (referred to in this context as schema_content) is
   # typically a Hash (JSON object) or a boolean.
   module Schema
-    autoload :Application, 'jsi/schema/application'
-    autoload :Validation, 'jsi/schema/validation'
+    autoload(:Element, 'jsi/schema/element')
+    autoload(:Vocabulary, 'jsi/schema/vocabulary')
+    autoload(:Dialect, 'jsi/schema/dialect')
+    autoload(:Cxt, 'jsi/schema/cxt')
+
+    autoload(:Elements, 'jsi/schema/elements')
 
     autoload :Issue, 'jsi/schema/issue'
-    autoload :Ref, 'jsi/schema/ref'
+    autoload(:DynamicAnchorMap, 'jsi/schema/dynamic_anchor_map')
 
     autoload :SchemaAncestorNode, 'jsi/schema/schema_ancestor_node'
 
     autoload :Draft04, 'jsi/schema/draft04'
     autoload :Draft06, 'jsi/schema/draft06'
     autoload :Draft07, 'jsi/schema/draft07'
-
-    class Error < StandardError
-    end
+    autoload(:Draft202012, 'jsi/schema/draft202012')
 
     # an exception raised when a thing is expected to be a JSI::Schema, but is not
-    class NotASchemaError < Error
+    class NotASchemaError < TypeError
     end
 
-    # an exception raised when we are unable to resolve a schema reference
-    class ReferenceError < StandardError
+    class NotAMetaSchemaError < TypeError
     end
 
-    # extends any schema which uses the keyword '$id' to identify its canonical URI
-    module BigMoneyId
-      # the contents of a $id keyword whose value is a string, or nil
-      # @return [#to_str, nil]
-      def id
-        if keyword?('$id') && schema_content['$id'].respond_to?(:to_str)
-          schema_content['$id']
-        else
-          nil
-        end
-      end
-    end
-
-    # extends any schema which uses the keyword 'id' to identify its canonical URI
-    module OldId
-      # the contents of an `id` keyword whose value is a string, or nil
-      # @return [#to_str, nil]
-      def id
-        if keyword?('id') && schema_content['id'].respond_to?(:to_str)
-          schema_content['id']
-        else
-          nil
-        end
-      end
-    end
-
-    # extends any schema which defines an anchor as a URI fragment in the schema id
-    module IdWithAnchor
-      # a URI for the schema's id, unless the id defines an anchor in its
-      # fragment. nil if the schema defines no id.
-      # @return [Addressable::URI, nil]
-      def id_without_fragment
-        if id
-          id_uri = Util.uri(id)
-          if id_uri.merge(fragment: nil).empty?
-            # fragment-only id is just an anchor
-            # e.g. #foo
-            nil
-          elsif id_uri.fragment == nil
-            # no fragment
-            # e.g. http://localhost:1234/bar
-            id_uri
-          elsif id_uri.fragment == ''
-            # empty fragment
-            # e.g. http://json-schema.org/draft-07/schema#
-            id_uri.merge(fragment: nil).freeze
-          elsif jsi_schema_base_uri && jsi_schema_base_uri.join(id_uri).merge(fragment: nil) == jsi_schema_base_uri
-            # the id, resolved against the base uri, consists of the base uri plus an anchor fragment.
-            # so there's no non-fragment id.
-            # e.g. base uri is http://localhost:1234/bar
-            #        and id is http://localhost:1234/bar#foo
-            nil
-          else
-            # e.g. http://localhost:1234/bar#foo
-            id_uri.merge(fragment: nil).freeze
-          end
-        else
-          nil
-        end
+    # @deprecated alias after v0.8
+    # an exception raised when we are unable to resolve a schema reference
+    ReferenceError = ResolutionError
+
+    # A reference to a schema identified by a given URI.
+    # {#resolve} will return a Schema, and param `referrer` must be a Schema.
+    class Ref < Ref
+      # @param ref_schema [Schema] deprecated; use `referrer`
+      def initialize(ref, ref_schema: nil, **kw)
+        super(ref, referrer: ref_schema, **kw)
       end
 
-      # an anchor defined by a non-empty fragment in the id uri
-      # @return [String]
-      def anchor
-        if id
-          id_uri = Util.uri(id)
-          if id_uri.fragment == ''
-            nil
-          else
-            id_uri.fragment
-          end
-        else
-          nil
-        end
-      end
-    end
-
-    # @private
-    module IntegerAllows0Fraction
-      # is `value` an integer?
-      # @private
-      # @param value
       # @return [Boolean]
-      def internal_integer?(value)
-        value.is_a?(Integer) || (value.is_a?(Numeric) && value % 1.0 == 0.0)
+      def resolve_schema?
+        true
       end
-    end
 
-    # @private
-    module IntegerDisallows0Fraction
-      # is `value` an integer?
-      # @private
-      # @param value
-      # @return [Boolean]
-      def internal_integer?(value)
-        value.is_a?(Integer)
+      # @deprecated after v0.8
+      def deref_schema
+        resolve
       end
     end
 
@@ -144,86 +69,80 @@ module JSI
     #
     # A schema is indicated as describing other schemas using the {Schema#describes_schema!} method.
     module MetaSchema
-      # @return [Set<Module>]
-      attr_reader(:schema_implementation_modules)
+      # @return [Schema::Dialect]
+      attr_reader(:described_dialect)
 
       # Instantiates the given schema content as a JSI Schema.
       #
-      # By default, the schema will be registered with the {JSI.schema_registry}.
-      # This can be controlled by params `register` and `schema_registry`.
+      # By default, the schema will be registered with the {JSI.registry}.
+      # This can be controlled by the `register` param and {Base::Conf#registry `registry`} {Base::Conf configuration}.
       #
       # By default, the `schema_content` will have any Symbol keys of Hashes replaced with Strings
       # (recursively through the document). This is controlled by the param `stringify_symbol_keys`.
       #
       # Schemas instantiated with `new_schema` are immutable, their content transformed using
-      # the `to_immutable` param.
-      #
-      # @param schema_content an object to be instantiated as a JSI Schema - typically a Hash
-      # @param uri [#to_str, Addressable::URI] The retrieval URI of the schema document.
-      #   If specified, the root schema will be identified by this URI, in addition
-      #   to any absolute URI declared with an id keyword, for resolution in the `schema_registry`.
-      #
-      #   It is rare that this needs to be specified. Most schemas, if they use absolute URIs, will
-      #   use the `$id` keyword (`id` in draft 4) to specify this. A different retrieval URI is useful
-      #   in unusual cases:
+      # the {Base::Conf configured} {Base::Conf#to_immutable `to_immutable`}.
       #
-      #     - A schema in the document uses relative URIs for `$id` or `$ref` without an absolute id in an
-      #       ancestor schema - these will be resolved relative to this URI
-      #     - Another schema refers with `$ref` to the schema being instantiated by this retrieval URI,
-      #       rather than an id declared in the schema - the schema is resolvable by this URI in the
-      #       `schema_registry`.
-      # @param register [Boolean] Whether the instantiated schema and any subschemas with absolute URIs
-      #   will be registered in the schema registry indicated by param `schema_registry`.
-      # @param schema_registry [SchemaRegistry, nil] The registry this schema will use.
+      # Parameters are passed to {SchemaSet#new_jsi} and are documented there, but some have
+      # different defaults for new_schema.
       #
-      #   - The schema and subschemas will be registered here with any declared URI,
-      #     unless the `register` param is false.
-      #   - References from within the schema (typically from `$ref` keywords) are resolved using this registry.
-      # @param stringify_symbol_keys [Boolean] Whether the schema content will have any Symbol keys of Hashes
-      #   replaced with Strings (recursively through the document).
-      #   Replacement is done on a copy; the given schema content is not modified.
-      # @param to_immutable (see SchemaSet#new_jsi)
-      # @yield If a block is given, it is evaluated in the context of the schema's JSI schema module
-      #   using [Module#module_exec](https://ruby-doc.org/core/Module.html#method-i-module_exec).
-      # @return [JSI::Base subclass + JSI::Schema] a JSI which is a {JSI::Schema} whose content comes from
-      #   the given `schema_content` and whose schemas are this schema's inplace applicators.
+      # @param schema_content an object to be instantiated as a JSI Schema - typically a Hash
+      # @param base_uri
+      # @param register
+      # @param stringify_symbol_keys
+      # @param conf_kw (see SchemaSet#new_jsi)
+      # @return [Base + Schema] A JSI which is a {Schema} whose content comes from
+      #   the given `schema_content` and whose schemas are this meta-schema's in-place applicators.
       def new_schema(schema_content,
-          uri: nil,
+          base_uri: nil,
           register: true,
-          schema_registry: JSI.schema_registry,
           stringify_symbol_keys: true,
-          to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE,
-          &block
+          **conf_kw
       )
-        schema_jsi = new_jsi(schema_content,
-          uri: uri,
+        raise(BlockGivenError) if block_given?
+        new_jsi(schema_content,
+          base_uri: base_uri,
           register: register,
-          schema_registry: schema_registry,
           stringify_symbol_keys: stringify_symbol_keys,
-          to_immutable: to_immutable,
+          **conf_kw,
           mutable: false,
         )
-
-        schema_jsi.jsi_schema_module_exec(&block) if block
-
-        schema_jsi
       end
 
       # Instantiates the given schema content as a JSI Schema, passing all params to
       # {Schema::MetaSchema#new_schema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
       #
+      # @yield If a block is given, it is evaluated in the context of the schema module
+      #   using [Module#module_exec](https://ruby-doc.org/core/Module.html#method-i-module_exec).
       # @return [JSI::SchemaModule] the JSI Schema Module of the instantiated schema
       def new_schema_module(schema_content, **kw, &block)
-        new_schema(schema_content, **kw, &block).jsi_schema_module
+        schema_jsi = new_schema(schema_content, **kw)
+        schema_jsi.jsi_schema_module_exec(&block) if block
+        schema_jsi.jsi_schema_module
       end
     end
 
-    class << self
+    # @private
+    module ExtendedInitialize
       def extended(o)
         super
         o.send(:jsi_schema_initialize)
       end
+
+      def included(m)
+        super
+        return if m.is_a?(Class)
+
+        # if a module (m) includes Schema, and an object (o) is extended with m,
+        # then o should have #jsi_schema_initialize called, but Schema.extended is not called,
+        # so m needs its own .extended method to call jsi_schema_initialize.
+        # note: extending m with ExtendedInitialize for .extended, rather than m.define_singleton_method(:extended),
+        # avoids possibly clobbering an existing singleton .extended method the module has defined.
+        m.extend(ExtendedInitialize)
+      end
     end
+
+    extend(ExtendedInitialize)
   end
 
   class << self
@@ -251,8 +170,9 @@ module JSI
       #
       # The meta-schema that describes the schema must be indicated:
       #
-      # - If the schema object has a `$schema` property, that URI is resolved using the `schema_registry`
-      #   param (by default {JSI.schema_registry}), and that meta-schema is used. For example:
+      # - If the schema object has a `$schema` property, that URI is resolved using the
+      #   {Base::Conf configured} {Base::Conf#registry `registry`} (by default {JSI.registry JSI.registry}),
+      #   and that meta-schema is used. For example:
       #
       #   ```ruby
       #   JSI.new_schema({
@@ -283,45 +203,44 @@ module JSI
       # specifying a `default_metaschema` is to call `new_schema` on the
       # {Schema::MetaSchema#new_schema meta-schema} or its
       # {SchemaModule::MetaSchemaModule#new_schema schema module}, e.g.
-      # `JSI::JSONSchemaDraft07.new_schema(my_schema_content)`
+      # `JSI::JSONSchemaDraft07.new_schema(my_schema_content)`. This will ignore any `$schema` keyword
+      # that may be present.
       #
       # Schemas instantiated with `new_schema` are immutable, their content transformed using
-      # the `to_immutable` param.
+      # the {Base::Conf configured} {Base::Conf#to_immutable `to_immutable`}.
+      #
+      # Most parameters are passed to {SchemaSet#new_jsi} and are documented there, but some have
+      # different defaults for JSI.new_schema.
       #
       # @param schema_content (see Schema::MetaSchema#new_schema)
       # @param default_metaschema [Schema::MetaSchema, SchemaModule::MetaSchemaModule, #to_str]
       #   Indicates the meta-schema to use if the given `schema_content` does not have a `$schema` property.
       #   This may be a meta-schema or a meta-schema's schema module (e.g. `JSI::JSONSchemaDraft07`),
       #   or a URI (as would be in a `$schema` keyword).
-      # @param uri (see Schema::MetaSchema#new_schema)
-      # @param register (see Schema::MetaSchema#new_schema)
-      # @param schema_registry (see Schema::MetaSchema#new_schema)
-      # @param stringify_symbol_keys (see Schema::MetaSchema#new_schema)
-      # @param to_immutable (see Schema::DescribesSchema#new_schema)
-      # @yield (see Schema::MetaSchema#new_schema)
-      # @return [JSI::Base subclass + JSI::Schema] a JSI which is a {JSI::Schema} whose content comes from
-      #   the given `schema_content` and whose schemas are inplace applicators of the indicated meta-schema
+      # @param base_uri
+      # @param register
+      # @param stringify_symbol_keys
+      # @param conf_kw (see SchemaSet#new_jsi)
+      # @return [Base + Schema] A JSI which is a {Schema} whose content comes from
+      #   the given `schema_content` and whose schemas are in-place applicators of the indicated meta-schema.
       def new_schema(schema_content,
           default_metaschema: nil,
-          # params of Schema::MetaSchema#new_schema have their default values repeated here. delegating in a splat
-          # would remove repetition, but yard doesn't display delegated defaults with its (see X) directive.
-          uri: nil,
+          base_uri: nil,
           register: true,
-          schema_registry: JSI.schema_registry,
           stringify_symbol_keys: true,
-          to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE,
-          &block
+          **conf_kw
       )
+        raise(BlockGivenError) if block_given?
         new_schema_params = {
-          uri: uri,
+          base_uri: base_uri,
           register: register,
-          schema_registry: schema_registry,
           stringify_symbol_keys: stringify_symbol_keys,
-          to_immutable: to_immutable,
+          **conf_kw,
         }
+        conf = Base::Conf.new(**conf_kw) # some redundancy instantiating this - not passed to MetaSchema#new_schema, just used in this method
         default_metaschema_new_schema = -> {
           default_metaschema = if default_metaschema
-            Schema.ensure_metaschema(default_metaschema, name: "default_metaschema")
+            Schema.ensure_metaschema(default_metaschema, name: "default_metaschema", registry: conf.registry)
           elsif self.default_metaschema
             self.default_metaschema
           else
@@ -336,7 +255,7 @@ module JSI
               "instantiating schema_content: #{schema_content.pretty_inspect.chomp}",
             ].join("\n"))
           end
-          default_metaschema.new_schema(schema_content, **new_schema_params, &block)
+          default_metaschema.new_schema(schema_content, **new_schema_params)
         }
         if schema_content.is_a?(Schema)
           raise(TypeError, [
@@ -354,8 +273,8 @@ module JSI
             unless id.respond_to?(:to_str)
               raise(ArgumentError, "given schema_content keyword `$schema` is not a string")
             end
-            metaschema = Schema.ensure_metaschema(id, name: '$schema', schema_registry: schema_registry)
-            metaschema.new_schema(schema_content, **new_schema_params, &block)
+            metaschema = Schema.ensure_metaschema(id, name: '$schema', registry: conf.registry)
+            metaschema.new_schema(schema_content, **new_schema_params)
           else
             default_metaschema_new_schema.call
           end
@@ -372,11 +291,10 @@ module JSI
       # ensure the given object is a JSI Schema
       #
       # @param schema [Object] the thing the caller wishes to ensure is a Schema
-      # @param msg [#to_s, #to_ary] lines of the error message preceding the pretty-printed schema param
-      #   if the schema param is not a schema
+      # @yieldreturn [#to_s, #to_ary] first line(s) of the error message, overriding the default
       # @raise [NotASchemaError] if the schema param is not a schema
       # @return [Schema] the given schema
-      def ensure_schema(schema, msg: "indicated object is not a schema:", reinstantiate_as: nil)
+      def ensure_schema(schema, reinstantiate_as: nil)
         if schema.is_a?(Schema)
           schema
         else
@@ -384,27 +302,33 @@ module JSI
             # TODO warn; behavior is undefined and I hate this implementation
 
             result_schema_indicated_schemas = SchemaSet.new(schema.jsi_indicated_schemas + reinstantiate_as)
-            result_schema_applied_schemas = result_schema_indicated_schemas.inplace_applicator_schemas(schema.jsi_node_content)
+            result_schema_applied_schemas = result_schema_indicated_schemas.each_yield_set do |is, y|
+              is.each_inplace_applicator_schema(schema.jsi_node_content, &y)
+            end
 
             result_schema_class = JSI::SchemaClasses.class_for_schemas(result_schema_applied_schemas,
               includes: SchemaClasses.includes_for(schema.jsi_node_content),
               mutable: schema.jsi_mutable?,
             )
 
-            result_schema_class.new(schema.jsi_document,
+            result_schema_class.new(
+              jsi_document: schema.jsi_document,
               jsi_ptr: schema.jsi_ptr,
               jsi_indicated_schemas: result_schema_indicated_schemas,
-              jsi_schema_base_uri: schema.jsi_schema_base_uri,
+              jsi_base_uri: schema.jsi_base_uri,
               jsi_schema_resource_ancestors: schema.jsi_schema_resource_ancestors,
-              jsi_schema_registry: schema.jsi_schema_registry,
-              jsi_content_to_immutable: schema.jsi_content_to_immutable,
-              jsi_root_node: schema.jsi_ptr.root? ? nil : schema.jsi_root_node, # bad
-            )
+              jsi_schema_dynamic_anchor_map: schema.jsi_schema_dynamic_anchor_map,
+              jsi_conf: schema.equal?(schema.jsi_root_node) ? schema.jsi_conf : nil,
+              jsi_root_node: schema.equal?(schema.jsi_root_node) ? nil : schema.jsi_root_node, # bad
+            ).send(:jsi_initialized)
           else
-            raise(NotASchemaError, [
-              *msg,
-              schema.pretty_inspect.chomp,
-            ].join("\n"))
+            msg = []
+            msg.concat([*(block_given? ? yield : "indicated object is not a schema:")])
+            msg << schema.pretty_inspect.chomp
+            if schema.is_a?(Base)
+              msg << "its schemas (which should include a Meta-Schema): #{schema.jsi_schemas.pretty_inspect.chomp}"
+            end
+            raise(NotASchemaError, msg.compact.join("\n"))
           end
         end
       end
@@ -415,11 +339,11 @@ module JSI
       # @param metaschema [Schema::MetaSchema, SchemaModule::MetaSchemaModule, #to_str]
       # @raise [TypeError] if the param does not indicate a meta-schema
       # @return [Base + Schema + Schema::MetaSchema]
-      def ensure_metaschema(metaschema, name: nil, schema_registry: JSI.schema_registry)
+      def ensure_metaschema(metaschema, name: nil, registry: JSI.registry)
         if metaschema.respond_to?(:to_str)
-          schema = Schema::Ref.new(metaschema, schema_registry: schema_registry).deref_schema
+          schema = Schema::Ref.new(metaschema, registry: registry).resolve
           if !schema.describes_schema?
-            raise(TypeError, [name, "URI indicates a schema that is not a meta-schema: #{metaschema.pretty_inspect.chomp}"].compact.join(" "))
+            raise(NotAMetaSchemaError, [name, "URI indicates a schema that is not a meta-schema: #{metaschema.pretty_inspect.chomp}"].compact.join(" "))
           end
           schema
         elsif metaschema.is_a?(SchemaModule::MetaSchemaModule)
@@ -427,7 +351,7 @@ module JSI
         elsif metaschema.is_a?(Schema::MetaSchema)
           metaschema
         else
-          raise(TypeError, "#{name || "param"} does not indicate a meta-schema: #{metaschema.pretty_inspect.chomp}")
+          raise(NotAMetaSchemaError, "#{name || "param"} does not indicate a meta-schema: #{metaschema.pretty_inspect.chomp}")
         end
       end
     end
@@ -444,6 +368,12 @@ module JSI
       end
     end
 
+    # @!method dialect
+    #   The dialect of this schema
+    #   @return [Schema::Dialect]
+    # note: defined on a meta-schema's schema module by Schema#describes_schema!
+
+
     # the underlying JSON data used to instantiate this JSI::Schema.
     # this is an alias for {Base#jsi_node_content}, named for clarity in the context of working with
     # a schema.
@@ -458,83 +388,93 @@ module JSI
       schema_content.respond_to?(:to_hash) && schema_content.key?(keyword)
     end
 
-    # the URI of this schema, calculated from our `#id`, resolved against our `#jsi_schema_base_uri`
-    # @return [Addressable::URI, nil]
+    # Does this schema contain the given keyword with the given value?
+    # @return [Boolean]
+    def keyword_value?(keyword, value)
+      keyword?(keyword) && schema_content[keyword] == value
+    end
+
+    # the string contents of an `$id`/`id` keyword, or nil
+    # @return [#to_str, nil]
+    def id
+      dialect_invoke_each(:id).first
+    end
+
+    # @return [Enumerable<String>]
+    def anchors
+      anchors = Set[]
+      anchors.merge(dialect_invoke_each(:anchor))
+      anchors.merge(dialect_invoke_each(:dynamicAnchor))
+      anchors.freeze
+    end
+
+    # the URI of this schema, from an `$id` keyword, resolved against our `#jsi_base_uri`
+    # @deprecated after v0.8 - use `#jsi_resource_uri`
+    # @return [URI, nil]
     def schema_absolute_uri
-      if respond_to?(:id_without_fragment) && id_without_fragment
-        if jsi_schema_base_uri
-          jsi_schema_base_uri.join(id_without_fragment).freeze
+      jsi_resource_uri
+    end
+
+    # @deprecated after v0.8 - use `#jsi_resource_uris`
+    # @return [Enumerable<URI>]
+    def schema_absolute_uris
+      jsi_resource_uris
+    end
+
+    # @yield [URI]
+    private def jsi_each_resource_uri_compute
+      dialect_invoke_each(:id_without_fragment) do |id_without_fragment|
+        if jsi_base_uri
+          yield(jsi_base_uri.join(id_without_fragment))
         elsif id_without_fragment.absolute?
-          id_without_fragment
-        else
-          # TODO warn / schema_error
-          nil
+          yield(id_without_fragment)
         end
       end
+      super
     end
 
     # a nonrelative URI which refers to this schema.
     # `nil` if no ancestor of this schema defines an id.
     # see {#schema_uris} for all URIs known to refer to this schema.
-    # @return [Addressable::URI, nil]
+    # @return [URI, nil]
     def schema_uri
       schema_uris.first
     end
 
     # nonrelative URIs (that is, absolute, but possibly with a fragment) which refer to this schema
-    # @return [Array<Addressable::URI>]
+    # @return [Array<URI>]
     def schema_uris
-      @schema_uris_map[]
-    end
-
-    private def schema_uris_compute(**_) # TODO remove **_ eventually (keyword argument compatibility)
-        each_schema_uri.to_a
+      @schema_uris_map[schema_content: schema_content]
     end
 
-    # see {#schema_uris}
-    # @yield [Addressable::URI]
-    # @return [Enumerator, nil]
-    def each_schema_uri
-      return to_enum(__method__) unless block_given?
-
-      yield schema_absolute_uri if schema_absolute_uri
-
-      ancestor_schemas = jsi_subschema_resource_ancestors.reverse_each.select do |resource|
-        resource.schema_absolute_uri
-      end
+    # @yield [URI]
+    private def schema_uris_compute(&block)
+      jsi_resource_uris.each(&block)
 
-      anchored = respond_to?(:anchor) ? anchor : nil
-      ancestor_schemas.each do |ancestor_schema|
-        if anchored
-          if ancestor_schema.jsi_anchor_subschema(anchor) == self
-            yield(ancestor_schema.schema_absolute_uri.merge(fragment: anchor).freeze)
-          else
-            anchored = false
+      if jsi_resource_root
+        anchors.each do |anchor|
+          jsi_resource_root.jsi_resource_uris.each do |uri|
+            yield(uri.merge(fragment: anchor))
           end
         end
+      end
 
+      jsi_subschema_resource_ancestors.reverse_each do |ancestor_schema|
         relative_ptr = jsi_ptr.relative_to(ancestor_schema.jsi_ptr)
-        yield(ancestor_schema.schema_absolute_uri.merge(fragment: relative_ptr.fragment).freeze)
+        ancestor_schema.jsi_resource_uris.each do |uri|
+          yield(uri.merge(fragment: relative_ptr.fragment))
+        end
       end
 
       nil
     end
 
-    # a module which extends all instances of this schema. this may be opened by the application to add
-    # methods to schema instances.
-    #
-    # some functionality is also defined on the module itself (its singleton class, not for its instances):
-    #
-    # - the module is extended with {JSI::SchemaModule}, which defines .new_jsi to instantiate instances
-    #   of this schema (see {#new_jsi}).
-    # - properties described by this schema's metaschema are defined as methods to get subschemas' schema
-    #   modules, so for example `schema.jsi_schema_module.items` returns the same module
-    #   as `schema.items.jsi_schema_module`.
-    # - method .schema which returns this schema.
+    # The {SchemaModule JSI Schema Module} for this schema.
+    # JSI instances described by this schema are instances of this module.
     #
     # @return [SchemaModule]
     def jsi_schema_module
-      JSI::SchemaClasses.module_for_schema(self)
+      jsi_schema_module_connection
     end
 
     # Evaluates the given block in the context of this schema's JSI schema module.
@@ -547,28 +487,40 @@ module JSI
       jsi_schema_module.module_exec(*a, **kw, &block)
     end
 
+    # @return [String, nil]
+    def jsi_schema_module_name
+      # don't hit #jsi_schema_module - avoid creating module, avoid erroring for MSN::BootstrapSchema
+      @memos[:schema_module_connection] && @memos[:schema_module_connection].name
+    end
+
+    # @return [String, nil]
+    def jsi_schema_module_name_from_ancestor
+      is_a?(Base) ? jsi_schema_module.name_from_ancestor : nil
+    end
+
     # Instantiates a new JSI whose content comes from the given `instance` param.
-    # This schema indicates the schemas of the JSI - its schemas are inplace
+    # This schema indicates the schemas of the JSI - its schemas are in-place
     # applicators of this schema which apply to the given instance.
     #
-    # @param (see SchemaSet#new_jsi)
-    # @return [JSI::Base subclass] a JSI whose content comes from the given instance and whose schemas are
-    #   inplace applicators of this schema.
+    # All parameters are passed to {SchemaSet#new_jsi}.
+    #
+    # @return [Base] a JSI whose content comes from the given instance and whose schemas are
+    #   in-place applicators of this schema.
     def new_jsi(instance, **kw)
+      raise(BlockGivenError) if block_given?
       SchemaSet[self].new_jsi(instance, **kw)
     end
 
-    # @param keyword schema keyword e.g. "$ref", "$schema"
+    # @param ref [#to_str] ref URI
     # @return [Schema::Ref]
-    def schema_ref(keyword = "$ref")
-      raise(ArgumentError, "keyword not present: #{keyword}") unless keyword?(keyword)
-      @schema_ref_map[keyword: keyword, value: schema_content[keyword]]
+    def schema_ref(ref = schema_content["$ref"])
+      @schema_ref_map[ref]
     end
 
     # Does this schema itself describe a schema? I.e. is this schema a meta-schema?
     # @return [Boolean]
     def describes_schema?
-      jsi_schema_module <= JSI::Schema || false
+      is_a?(Schema::MetaSchema)
     end
 
     # Is this a JSI Schema?
@@ -580,30 +532,36 @@ module JSI
     # Indicates that this schema describes schemas, i.e. it is a meta-schema.
     # this schema is extended with {Schema::MetaSchema} and its {#jsi_schema_module} is extended
     # with {SchemaModule::MetaSchemaModule}, and the JSI Schema Module will include
-    # JSI::Schema and the given modules.
+    # JSI::Schema.
     #
-    # @param schema_implementation_modules [Enumerable<Module>] modules which implement the functionality of
-    #   the schema to extend schemas described by this schema.
+    # @param dialect [Schema::Dialect, nil] dialect may be passed, or inferred from `$vocabulary`
     # @return [void]
-    def describes_schema!(schema_implementation_modules)
-      schema_implementation_modules = Util.ensure_module_set(schema_implementation_modules)
+    def describes_schema!(dialect = nil)
+      # TODO rm bridge code hax
+      dialect = dialect.first::DIALECT if dialect.is_a?(Array) && dialect.size == 1
+
+      if !dialect
+        raise(ArgumentError, "no dialect given and no $vocabulary hash/object") if !schema_content['$vocabulary'].respond_to?(:to_hash)
+        dialect = Schema::Dialect.from_xvocabulary(schema_content['$vocabulary'], registry: jsi_registry)
+      end
+
+      raise(TypeError) if !dialect.is_a?(Schema::Dialect)
 
-      if describes_schema?
-        # this schema, or one equal to it, has already had describes_schema! called on it.
+      if jsi_schema_module <= Schema
+        # this schema has already had describes_schema! called on it.
         # this is to be avoided, but is not particularly a problem.
-        # it is a bug if it was called different times with different schema_implementation_modules, though.
-        unless jsi_schema_module.schema_implementation_modules == schema_implementation_modules
-          raise(ArgumentError, "this schema already describes a schema with different schema_implementation_modules")
+        # it is a bug if it was called different times with different dialect, though.
+        if @described_dialect != dialect
+          raise(ArgumentError, "this schema already describes a schema with different dialect")
         end
       else
         jsi_schema_module.include(Schema)
-        schema_implementation_modules.each do |mod|
-          jsi_schema_module.include(mod)
-        end
+        jsi_schema_module.send(:define_method, :dialect) { dialect }
+        proc { |metaschema| jsi_schema_module.send(:define_method, :metaschema) { metaschema } }[self]
         jsi_schema_module.extend(SchemaModule::MetaSchemaModule)
       end
 
-      @schema_implementation_modules = schema_implementation_modules
+      @described_dialect = dialect
       extend(Schema::MetaSchema)
 
       nil
@@ -617,15 +575,21 @@ module JSI
     # If no ancestor schema has an absolute uri, the schema_resource_root is the {Base#jsi_root_node document's root node}.
     # In this case, the resource root may or may not be a schema itself.
     #
+    # @deprecated after v0.8
     # @return [JSI::Base] resource containing this schema
     def schema_resource_root
-      jsi_subschema_resource_ancestors.last || jsi_root_node
+      jsi_resource_root
     end
 
     # is this schema the root of a schema resource?
     # @return [Boolean]
+    def jsi_is_resource_root?
+      super || jsi_resource_uris.any?
+    end
+
+    # @deprecated after v0.8
     def schema_resource_root?
-      jsi_ptr.root? || !!schema_absolute_uri
+      jsi_is_resource_root?
     end
 
     # a subschema of this Schema
@@ -633,78 +597,202 @@ module JSI
     # @param subptr [JSI::Ptr, #to_ary] a relative pointer, or array of tokens, pointing to the subschema
     # @return [JSI::Schema] the subschema at the location indicated by subptr. self if subptr is empty.
     def subschema(subptr)
-          subptr = Ptr.ary_ptr(subptr)
-          Schema.ensure_schema(jsi_descendent_node(subptr), msg: [
-            "subschema is not a schema at pointer: #{subptr.pointer}"
-          ])
+      Schema.ensure_schema(jsi_descendent_node(subptr)) { "subschema is not a schema at pointer: #{Ptr.ary_ptr(subptr).pointer}" }
     end
 
-    # a schema in the same schema resource as this one (see {#schema_resource_root}) at the given
+    # A schema in the same schema resource as this one (see {Schema::SchemaAncestorNode#jsi_resource_root}) at the given
     # pointer relative to the root of the schema resource.
     #
     # @param ptr [JSI::Ptr, #to_ary] a pointer to a schema from our schema resource root
     # @return [JSI::Schema] the schema pointed to by ptr
     def resource_root_subschema(ptr)
-          ptr = Ptr.ary_ptr(ptr)
-          Schema.ensure_schema(schema_resource_root.jsi_descendent_node(ptr),
-            reinstantiate_as: jsi_schemas.select(&:describes_schema?)
+          Schema.ensure_schema(jsi_resource_root.jsi_descendent_node(ptr),
+            reinstantiate_as: jsi_conf.reinstantiate_nonschemas && jsi_schemas.select(&:describes_schema?),
           )
     end
 
-    # a set of inplace applicator schemas of this schema (from $ref, allOf, etc.) which apply to the
-    # given instance.
-    #
-    # the returned set will contain this schema itself, unless this schema contains a $ref keyword.
-    #
-    # @param instance [Object] the instance to check any applicators against
-    # @return [JSI::SchemaSet] matched applicator schemas
-    def inplace_applicator_schemas(instance)
-      SchemaSet.new(each_inplace_applicator_schema(instance))
+    # @yield [Schema]
+    def jsi_each_descendent_schema(&block)
+      return(to_enum(__method__)) unless block_given?
+
+      yield(self)
+      dialect_invoke_each(:subschema) { |ptr| subschema(ptr).jsi_each_descendent_schema(&block) }
+    end
+
+    # yields each descendent of this node (including itself) within the same resource that is a Schema
+    # @yield [Schema]
+    def jsi_each_descendent_schema_same_resource(&block)
+      return(to_enum(__method__)) unless block_given?
+
+      yield(self)
+      dialect_invoke_each(:subschema) do |ptr|
+        desc = subschema(ptr)
+        if !desc.jsi_is_resource_root?
+          desc.jsi_each_descendent_schema_same_resource(&block)
+        end
+      end
+    end
+
+    # @yield [Ptr]
+    def each_immediate_subschema_ptr
+      return(to_enum(__method__)) unless block_given?
+
+      dialect_invoke_each(:subschema) { |ptr| yield(Ptr.ary_ptr(ptr)) }
     end
 
-    # yields each inplace applicator schema which applies to the given instance.
+    # @private
+    # @yield each in-place applicator schema and params yielded from action :inplace_applicate
+    def each_immediate_inplace_applicator_schema(
+        instance: ,
+        visited_refs: ,
+        collect_evaluated: ,
+        &block
+    )
+      # if collect_evaluated, applicators must validate the instance to set `evaluated`
+      if collect_evaluated || @inplace_application_requires_instance
+        dialect_invoke_each(:inplace_applicate, Cxt::InplaceApplication::WithInstance,
+          instance: instance,
+          visited_refs: visited_refs,
+          collect_evaluated: collect_evaluated,
+          &block
+        )
+      else
+        # memoize: if the instance is not used by any in-place applicator present in this schema,
+        # the schema can do in-place application once instead of for every instance,
+        # for a very substantial performance gain.
+        #
+        # :inplace_applicate yields (schema, **keywords)
+        # so @memos[:immediate_inplace_applicators] is a 2D Array of tuples (schema, keywords)
+        @memos[:immediate_inplace_applicators] ||= begin
+          immediate_inplace_applicators = []
+          dialect_invoke_each(:inplace_applicate, Cxt::InplaceApplication,
+            visited_refs: visited_refs,
+          ) do |s, **kw|
+            immediate_inplace_applicators.push([s, kw])
+          end
+          immediate_inplace_applicators.freeze
+        end
+
+        @memos[:immediate_inplace_applicators].each do |(s, kw)|
+          yield(s, **kw)
+        end
+        nil
+      end
+    end
+
+    # Yields each in-place applicator schema which applies to the given instance.
     #
-    # @param instance (see #inplace_applicator_schemas)
+    # @param instance [Object] the instance to check any applicators against
     # @param visited_refs [Enumerable<JSI::Schema::Ref>]
     # @yield [JSI::Schema]
-    # @return [nil, Enumerator] an Enumerator if invoked without a block; otherwise nil
+    # @return [nil]
     def each_inplace_applicator_schema(
         instance,
         visited_refs: Util::EMPTY_ARY,
         &block
     )
-      return to_enum(__method__, instance, visited_refs: visited_refs) unless block
-
-      catch(:jsi_application_done) do
-        internal_inplace_applicate_keywords(instance, visited_refs, &block)
+      each_immediate_inplace_applicator_schema(
+        instance: instance,
+        visited_refs: visited_refs,
+        collect_evaluated: false, # child application is not invoked so no evaluated children to collect
+      ) do |schema, ref: nil, applicate: true|
+        if schema.equal?(self) && !ref
+          yield(self)
+        elsif applicate
+          schema.each_inplace_applicator_schema(
+            instance,
+            visited_refs: Util.add_visited_ref(visited_refs, ref),
+            &block
+          )
+        end
       end
-
-      nil
-    end
-
-    # a set of child applicator subschemas of this schema which apply to the child of the given instance
-    # on the given token.
-    #
-    # @param token [Object] the array index or object property name for the child instance
-    # @param instance [Object] the instance to check any child applicators against
-    # @return [JSI::SchemaSet] child applicator subschemas of this schema for the given token
-    #   of the instance
-    def child_applicator_schemas(token, instance)
-      SchemaSet.new(each_child_applicator_schema(token, instance))
     end
 
     # yields each child applicator subschema (from properties, items, etc.) which applies to the child of
     # the given instance on the given token.
     #
-    # @param (see #child_applicator_schemas)
+    # @param token [Object] the array index or object property name for the child instance
+    # @param instance [Object] the instance to check any child applicators against
     # @yield [JSI::Schema]
     # @return [nil, Enumerator] an Enumerator if invoked without a block; otherwise nil
     def each_child_applicator_schema(token, instance, &block)
-      return to_enum(__method__, token, instance) unless block
+      dialect_invoke_each(:child_applicate,
+        Cxt::ChildApplication,
+        instance: instance,
+        token: token,
+        collect_evaluated: false,
+        collect_evaluated_validate: false,
+        evaluated: false,
+        &block
+      )
+    end
+
+    # For each in-place applicator schema that applies to the given instance, yields each child applicator
+    # of that schema that applies to the child of the instance on the given token.
+    #
+    # This method handles collection of whether the child was evaluated by any applicator
+    # when that evaluation is needed by either this schema or the caller (per param `collect_evaluated`).
+    # This is relevant to schemas containing `unevaluatedProperties` or `unevaluatedItems`.
+    #
+    # @param token [Object] array index or hash/object property name
+    # @param instance [Object]
+    # @param collect_evaluated [Boolean] Does the caller need this method to collect successful child evaluation?
+    #   Note: this method will still collect child evaluation if this schema needs it; this only needs to be
+    #   passed true when called by an in-place applicator schema that needs it (i.e. contains `unevaluated*`).
+    # @param collect_evaluated_validate [Boolean] See {Base::Conf#application_collect_evaluated_validate}
+    # @yield [Schema]
+    # @return [Boolean] if `collect_evaluated` is true, whether the child was successfully evaluated
+    #   by a child applicator schema. if `collect_evaluated` is false, undefined/void.
+    def each_inplace_child_applicator_schema(
+        token,
+        instance,
+        visited_refs: Util::EMPTY_ARY,
+        collect_evaluated: false,
+        collect_evaluated_validate: false,
+        &block
+    )
+      collect_evaluated ||= application_requires_evaluated
+      inplace_child_evaluated = false
+      applicate_self = false
 
-      internal_child_applicate_keywords(token, instance, &block)
+      each_immediate_inplace_applicator_schema(
+        instance: instance,
+        visited_refs: visited_refs,
+        collect_evaluated: collect_evaluated,
+      ) do |schema, ref: nil, applicate: true|
+        if schema.equal?(self) && !ref
+          applicate_self = true
+        elsif applicate || (collect_evaluated && !inplace_child_evaluated)
+          schema_evaluated = schema.each_inplace_child_applicator_schema(
+            token,
+            instance,
+            visited_refs: Util.add_visited_ref(visited_refs, ref),
+            collect_evaluated: collect_evaluated && !inplace_child_evaluated,
+            collect_evaluated_validate: collect_evaluated_validate,
+            # the `if` keyword needs to yield to here because it does affect `evaluated`,
+            # but it does not applicate itself/its applicators, so does not yield to the given block.
+            &(applicate ? block : proc { })
+          )
+          inplace_child_evaluated ||= collect_evaluated && schema_evaluated && (!collect_evaluated_validate || schema.instance_valid?(instance))
+        end
+      end
 
-      nil
+      if applicate_self
+        child_application = dialect.invoke(:child_applicate, Cxt::ChildApplication.new(
+          schema: self,
+          abort: false,
+          token: token,
+          instance: instance,
+          collect_evaluated: collect_evaluated,
+          collect_evaluated_validate: collect_evaluated_validate,
+          evaluated: inplace_child_evaluated,
+          block: block,
+        ))
+
+        child_application.evaluated
+      else
+        inplace_child_evaluated
+      end
     end
 
     # any object property names this schema indicates may be present on its instances.
@@ -712,24 +800,13 @@ module JSI
     # array of "required" property keys.
     # @return [Set]
     def described_object_property_names
-      @described_object_property_names_map[]
-    end
-
-    private def described_object_property_names_compute(**_) # TODO remove **_ eventually (keyword argument compatibility)
-        Set.new.tap do |property_names|
-          if schema_content.respond_to?(:to_hash) && schema_content['properties'].respond_to?(:to_hash)
-            property_names.merge(schema_content['properties'].keys)
-          end
-          if schema_content.respond_to?(:to_hash) && schema_content['required'].respond_to?(:to_ary)
-            property_names.merge(schema_content['required'].to_ary)
-          end
-        end.freeze
+      @described_object_property_names_map[schema_content: schema_content]
     end
 
-    # validates the given instance against this schema
+    # Validates the given instance against this schema, returning a result with each validation error.
     #
     # @param instance [Object] the instance to validate against this schema
-    # @return [JSI::Validation::Result]
+    # @return [JSI::Validation::Result::Full]
     def instance_validate(instance)
       if instance.is_a?(SchemaAncestorNode)
         instance_ptr = instance.jsi_ptr
@@ -751,6 +828,15 @@ module JSI
       internal_validate_instance(Ptr[], instance, validate_only: true).valid?
     end
 
+    # Asserts that the given instance is valid against this schema.
+    # {JSI::Invalid} is raised if it is not.
+    #
+    # @raise [Invalid]
+    # @return [nil]
+    def instance_valid!(instance)
+      instance_validate(instance).valid!
+    end
+
     # validates the given instance against this schema
     #
     # @private
@@ -766,13 +852,14 @@ module JSI
         validate_only: false
     )
       if validate_only
-        result = JSI::Validation::VALID
+        result = JSI::Validation::Result::Valid.new
       else
-        result = JSI::Validation::FullResult.new
+        result = JSI::Validation::Result::Full.new
       end
       result_builder = result.class::Builder.new(
         result: result,
         schema: self,
+        abort: false,
         instance_ptr: instance_ptr,
         instance_document: instance_document,
         validate_only: validate_only,
@@ -780,43 +867,138 @@ module JSI
       )
 
       catch(:jsi_validation_result) do
-        # note: true/false are not valid as schemas in draft 4; they are only values of
-        # additionalProperties / additionalItems. since their behavior is undefined, though,
-        # it's fine for them to behave the same as boolean schemas in later drafts.
-        # I don't care about draft 4 to implement a different structuring for that.
-        if schema_content == true
-          # noop
-        elsif schema_content == false
-          result_builder.validate(false, 'instance is not valid against `false` schema')
-        elsif schema_content.respond_to?(:to_hash)
-          internal_validate_keywords(result_builder)
-        else
-          result_builder.schema_error('schema is not a boolean or a JSON object')
-        end
+        dialect.invoke(:validate, result_builder)
+
         result
       end.freeze
     end
 
+    # See {Base#jsi_as_child_default_as_jsi}. true for Schema, including boolean schemas.
+    def jsi_as_child_default_as_jsi
+      true
+    end
+
+    # @param action_name [Symbol]
+    # @param cxt_class [Class]
+    # @yield
+    def dialect_invoke_each(
+        action_name,
+        cxt_class = Cxt::Block,
+        **cxt_param,
+        &block
+    )
+      return(to_enum(__method__, action_name, cxt_class, **cxt_param)) unless block_given?
+
+      cxt = cxt_class.new(
+        schema: self,
+        abort: false,
+        block: block,
+        **cxt_param,
+      )
+      dialect.invoke(action_name, cxt)
+
+      nil
+    end
+
     # schema resources which are ancestors of any subschemas below this schema.
     # this may include this schema if this is a schema resource root.
     # @api private
     # @return [Array<JSI::Schema>]
     def jsi_subschema_resource_ancestors
-      if schema_resource_root?
+      if jsi_is_resource_root?
         jsi_schema_resource_ancestors.dup.push(self).freeze
       else
         jsi_schema_resource_ancestors
       end
     end
 
+    # @private
+    def jsi_next_schema_dynamic_anchor_map
+      return @memos[:next_schema_dynamic_anchor_map] if @memos.key?(:next_schema_dynamic_anchor_map)
+
+      if !dialect.elements.any? { |e| e.invokes?(:dynamicAnchor) }
+        return @memos[:next_schema_dynamic_anchor_map] = jsi_schema_dynamic_anchor_map
+      end
+      if !jsi_resource_root.is_a?(Schema)
+        # if the resource root is not a schema, then this schema does not add to dynamic_anchor_map.
+        # we could treat self as the anchor root, but that complicates DynamicAnchorMap#without_node.
+        return @memos[:next_schema_dynamic_anchor_map] = jsi_schema_dynamic_anchor_map
+      end
+
+      map = jsi_schema_dynamic_anchor_map
+
+      anchor_root = jsi_resource_root
+      descendent_schemas = [[anchor_root, Util::EMPTY_ARY]]
+
+      while !descendent_schemas.empty?
+        descendent_schema, ptrs = *descendent_schemas.shift
+
+        descendent_schema.dialect_invoke_each(:dynamicAnchor) do |anchor|
+          next if map.key?(anchor)
+          map = map.merge({
+            anchor => [anchor_root.jsi_with_schema_dynamic_anchor_map(Schema::DynamicAnchorMap::EMPTY), ptrs].freeze,
+          }).freeze
+        end
+
+        descendent_schema.each_immediate_subschema_ptr do |subptr|
+          # we want a schema at subptr to
+          # - check if it is a schema resource root
+          # - check for $dynamicAnchor
+          # can't use #subschema here (it would need to pass this method's result to instantiate the subschema);
+          # a minimal bootstrap schema is used instead.
+          # note: not using dialect.bootstrap_schema. this bootstrap is only used once, skip memoization.
+          descendent_subschema = MetaSchemaNode::BootstrapSchema.new(
+            dialect: dialect,
+            jsi_document: jsi_document,
+            jsi_ptr: descendent_schema.jsi_ptr + subptr,
+            # note: same as anchor_root.jsi_next_base_uri since we don't cross resource boundaries.
+            jsi_base_uri: descendent_schema.jsi_next_base_uri,
+          )
+          if !descendent_subschema.jsi_is_resource_root?
+            descendent_schemas.push([descendent_subschema, ptrs.dup.push(subptr).freeze])
+          end
+        end
+      end
+
+      @memos[:next_schema_dynamic_anchor_map] = map
+    end
+
+    # @private pending stronger stability of dynamic scope
+    def with_dynamic_scope_from(node)
+      node = node.jsi_node if node.is_a?(SchemaModule::Connection)
+      jsi_with_schema_dynamic_anchor_map(node.jsi_next_schema_dynamic_anchor_map)
+    end
+
+    # Does application require collection of evaluated children?
+    # (i.e. does the schema contain `unevaluatedItems` / `unevaluatedProperties`?)
+    # @private
+    # @return [Boolean]
+    attr_reader(:application_requires_evaluated)
+
+    # @private
+    # @return [#to_s, nil]
+    def jsi_schema_identifier(required: false)
+      name = jsi_schema_module_name_from_ancestor
+      return name if name
+      return schema_uri || (required ? jsi_ptr.uri : nil) if jsi_schema_dynamic_anchor_map.empty?
+      -"#{schema_uri || jsi_ptr.uri}#{jsi_schema_dynamic_anchor_map.anchor_schemas_identifier}"
+    end
+
     private
 
+    KEY_BY_NONE = proc { nil }
+
     def jsi_schema_initialize
-      @schema_ref_map = jsi_memomap(key_by: proc { |i| i[:keyword] }) do |keyword: , value: |
-        Schema::Ref.new(value, ref_schema: self)
+      # guard against being called twice on MetaSchemaNode, first from extend(Schema) then extend(jsi_schema_module) that includes Schema.
+      # both extends need to initialize for edge case of draft4's boolean schema that is not described by meta-schema.
+      instance_variable_defined?(:@jsi_schema_initialized) ? return : (@jsi_schema_initialized = true)
+      @schema_ref_map = Hash.new { |h, ref| h[ref] = Schema::Ref.new(ref, referrer: self) }
+      @schema_uris_map = jsi_memomap(key_by: KEY_BY_NONE) { to_enum(:schema_uris_compute).to_a.freeze }
+      @described_object_property_names_map = jsi_memomap(key_by: KEY_BY_NONE) do
+        Set.new(dialect_invoke_each(:described_object_property_names)).freeze
       end
-      @schema_uris_map = jsi_memomap(&method(:schema_uris_compute))
-      @described_object_property_names_map = jsi_memomap(&method(:described_object_property_names_compute))
+      @application_requires_evaluated = dialect_invoke_each(:application_requires_evaluated).any?
+      @inplace_application_requires_instance = dialect_invoke_each(:inplace_application_requires_instance).any?
     end
   end
 end