jsi 0.6.0 → 0.8.0

data/lib/jsi/jsi_coder.rb

@@ -29,12 +29,16 @@ module JSI
     #   will instantiate column data using the JSI schemas represented.
     # @param array [Boolean] whether the dumped data represent one instance of the schema,
     #   or an array of them. note that it may be preferable to simply use an array schema.
-    def initialize(schema, array: false)
+    # @param jsi_opt [Hash] keyword arguments to pass to {Schema#new_jsi} when loading
+    # @param as_json_opt [Hash] keyword arguments to pass to `#as_json` when dumping
+    def initialize(schema, array: false, jsi_opt: Util::EMPTY_HASH, as_json_opt: Util::EMPTY_HASH)
       unless schema.respond_to?(:new_jsi)
         raise(ArgumentError, "schema param does not respond to #new_jsi: #{schema.inspect}")
       end
       @schema = schema
       @array = array
+      @jsi_opt = jsi_opt
+      @as_json_opt = as_json_opt
     end
 
     # loads the database column to JSI instances of our schema
@@ -44,15 +48,15 @@ module JSI
     #   instance(s), or nil if data is nil
     def load(data)
       return nil if data.nil?
-      object = if @array
+
+      if @array
         unless data.respond_to?(:to_ary)
           raise TypeError, "expected array-like column data; got: #{data.class}: #{data.inspect}"
         end
-        data.map { |el| load_object(el) }
+        data.to_ary.map { |el| load_object(el) }
       else
         load_object(data)
       end
-      object
     end
 
     # dumps the object for the database
@@ -61,32 +65,30 @@ module JSI
     # @return [Object, Array, nil] the schema instance(s) of the JSI(s), or nil if object is nil
     def dump(object)
       return nil if object.nil?
-      jsonifiable = begin
-        if @array
-          unless object.respond_to?(:to_ary)
-            raise(TypeError, "expected array-like attribute; got: #{object.class}: #{object.inspect}")
-          end
-          object.map do |el|
-            dump_object(el)
-          end
-        else
-          dump_object(object)
+
+      if @array
+        unless object.respond_to?(:to_ary)
+          raise(TypeError, "expected array-like attribute; got: #{object.class}: #{object.inspect}")
         end
+        object.to_ary.map do |el|
+          dump_object(el)
+        end
+      else
+        dump_object(object)
       end
-      jsonifiable
     end
 
     private
     # @param data [Object]
     # @return [JSI::Base]
     def load_object(data)
-      @schema.new_jsi(data)
+      @schema.new_jsi(data, **@jsi_opt)
     end
 
     # @param object [JSI::Base, Object]
     # @return [Object]
     def dump_object(object)
-      JSI::Typelike.as_json(object)
+      JSI::Util.as_json(object, **@as_json_opt)
     end
   end
 end

data/lib/jsi/metaschema_node/bootstrap_schema.rb

@@ -1,32 +1,37 @@
 # frozen_string_literal: true
 
 module JSI
-  # @private
-  # internal class to bootstrap a metaschema. represents a schema without the complexity of JSI::Base. the
+  # internal class to bootstrap a meta-schema. represents a schema without the complexity of JSI::Base. the
   # schema is represented but schemas describing the schema are not.
   #
   # this class is to only be instantiated on nodes in the document that are known to be schemas.
   # Schema#subschema and Schema#resource_root_subschema are the intended mechanisms to instantiate subschemas
   # and resolve references. #[] and #jsi_root_node are not implemented.
   #
-  # metaschema instance modules are attached to generated subclasses of BootstrapSchema by
+  # schema implementation modules are included on generated subclasses of BootstrapSchema by
   # {SchemaClasses.bootstrap_schema_class}. that subclass is instantiated with a document and
   # pointer, representing a schema.
-  class MetaschemaNode::BootstrapSchema
-    include Util::Memoize
+  #
+  # BootstrapSchema does not support mutation; its document must be immutable.
+  #
+  # @api private
+  class MetaSchemaNode::BootstrapSchema
     include Util::FingerprintHash
     include Schema::SchemaAncestorNode
+    include Schema
 
     class << self
       def inspect
-        if self == MetaschemaNode::BootstrapSchema
-          name
+        if self == MetaSchemaNode::BootstrapSchema
+          name.freeze
         else
-          "#{name || MetaschemaNode::BootstrapSchema.name} (#{metaschema_instance_modules.map(&:inspect).join(', ')})"
+          -"#{name || MetaSchemaNode::BootstrapSchema.name} (#{schema_implementation_modules.map(&:inspect).join(', ')})"
         end
       end
 
-      alias_method :to_s, :inspect
+      def to_s
+        inspect
+      end
     end
 
     # @param jsi_ptr [JSI::Ptr] pointer to the schema in the document
@@ -36,15 +41,17 @@ module JSI
         jsi_ptr: Ptr[],
         jsi_schema_base_uri: nil
     )
-      unless respond_to?(:metaschema_instance_modules)
-        raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #metaschema_instance_modules")
-      end
-
-      jsi_initialize_memos
+      raise(Bug, "no #schema_implementation_modules") unless respond_to?(:schema_implementation_modules)
 
       self.jsi_ptr = jsi_ptr
       self.jsi_document = jsi_document
       self.jsi_schema_base_uri = jsi_schema_base_uri
+      self.jsi_schema_resource_ancestors = Util::EMPTY_ARY
+
+      @jsi_node_content = jsi_ptr.evaluate(jsi_document)
+      #chkbug raise(Bug, 'BootstrapSchema instance must be frozen') unless jsi_node_content.frozen?
+
+      super()
     end
 
     # document containing the schema content
@@ -53,13 +60,37 @@ module JSI
     # JSI::Ptr pointing to this schema within the document
     attr_reader :jsi_ptr
 
-    def jsi_node_content
-      jsi_ptr.evaluate(jsi_document)
+    attr_reader(:jsi_node_content)
+
+    # overrides {Schema#subschema}
+    def subschema(subptr)
+      self.class.new(
+        jsi_document,
+        jsi_ptr: jsi_ptr + subptr,
+        jsi_schema_base_uri: jsi_resource_ancestor_uri,
+      )
+    end
+
+    # overrides {Schema#resource_root_subschema}
+    def resource_root_subschema(ptr)
+      # BootstrapSchema does not track jsi_schema_resource_ancestors used by Schema#schema_resource_root;
+      # resource_root_subschema is always relative to the document root.
+      # BootstrapSchema also does not implement jsi_root_node or #[]. we instantiate the ptr directly
+      # rather than as a subschema from the root.
+      self.class.new(
+        jsi_document,
+        jsi_ptr: Ptr.ary_ptr(ptr),
+        jsi_schema_base_uri: nil,
+      )
     end
 
     # @return [String]
     def inspect
-      "\#<#{jsi_object_group_text.join(' ')} #{schema_content.inspect}>"
+      -"\#<#{jsi_object_group_text.join(' ')} #{schema_content.inspect}>"
+    end
+
+    def to_s
+      inspect
     end
 
     # pretty-prints a representation of self to the given printer
@@ -67,11 +98,9 @@ module JSI
     def pretty_print(q)
       q.text '#<'
       q.text jsi_object_group_text.join(' ')
-      q.group_sub {
-        q.nest(2) {
+      q.group(2) {
           q.breakable ' '
           q.pp schema_content
-        }
       }
       q.breakable ''
       q.text '>'
@@ -81,20 +110,26 @@ module JSI
     # @return [Array<String>]
     def jsi_object_group_text
       [
-        self.class.name || MetaschemaNode::BootstrapSchema.name,
-        "(#{metaschema_instance_modules.map(&:inspect).join(', ')})",
+        self.class.name || MetaSchemaNode::BootstrapSchema.name,
+        -"(#{schema_implementation_modules.map(&:inspect).join(', ')})",
         jsi_ptr.uri,
-      ]
+      ].freeze
     end
 
-    # @private
+    # see {Util::Private::FingerprintHash}
+    # @api private
     def jsi_fingerprint
       {
         class: self.class,
         jsi_ptr: @jsi_ptr,
         jsi_document: @jsi_document,
-        metaschema_instance_modules: metaschema_instance_modules,
-      }
+      }.freeze
+    end
+
+    private
+
+    def jsi_memomap_class
+      Util::MemoMap::Immutable
     end
   end
 end

data/lib/jsi/metaschema_node.rb

@@ -1,134 +1,140 @@
 # frozen_string_literal: true
 
 module JSI
-  # a MetaschemaNode is a JSI instance representing a node in a document which contains a metaschema.
-  # the root of the metaschema is pointed to by metaschema_root_ptr.
+  # A MetaSchemaNode is a JSI instance representing a node in a document that contains a meta-schema.
+  # The root of the meta-schema is pointed to by metaschema_root_ptr.
   # the schema describing the root of the document is pointed to by root_schema_ptr.
   #
   # like JSI::Base's normal subclasses, this class represents an instance of a schema set, an instance
   # which may itself be a schema. unlike JSI::Base, the document containing the instance and its schemas
-  # is the same, and a schema (the metaschema) may be an instance of itself.
+  # is the same, and a schema (the meta-schema) may be an instance of itself.
   #
   # unlike JSI::Base's normal subclasses, the schemas describing the instance are not part of the class.
-  # since the metaschema describes itself, attempting to construct a class from the JSI Schema Module of a
+  # Since the meta-schema describes itself, attempting to construct a class from the JSI Schema Module of a
   # schema which is itself an instance of that class results in a causality loop.
-  # instead, a MetaschemaNode calculates its {#jsi_schemas} and extends itself with their JSI Schema
+  # instead, a MetaSchemaNode calculates its {#jsi_schemas} and extends itself with their JSI Schema
   # modules during initialization.
-  # the MetaschemaNode of the metaschema is extended with its own JSI Schema Module.
+  # The MetaSchemaNode of the meta-schema is extended with its own JSI Schema Module.
   #
-  # if the MetaschemaNode's schemas include its self, it is extended with JSI::Metaschema.
+  # if the MetaSchemaNode's schemas include its self, it is extended with {JSI::Schema::MetaSchema}.
   #
-  # a MetaschemaNode is extended with JSI::Schema when it represents a schema - this is the case when
-  # the metaschema is one of its schemas.
-  class MetaschemaNode < Base
+  # a MetaSchemaNode is extended with JSI::Schema when it represents a schema - this is the case when
+  # the meta-schema is one of its schemas.
+  class MetaSchemaNode < Base
     autoload :BootstrapSchema, 'jsi/metaschema_node/bootstrap_schema'
 
-    # @param jsi_document the document containing the metaschema
-    # @param jsi_ptr [JSI::Ptr] ptr to this MetaschemaNode in jsi_document
-    # @param metaschema_instance_modules [Enumerable<Module>] modules which implement the functionality of the
-    #   schema, to be applied to every schema which is an instance of the metaschema. this must include
-    #   JSI::Schema directly or indirectly. these are the {Schema#jsi_schema_instance_modules} of the
-    #   metaschema.
-    # @param metaschema_root_ptr [JSI::Ptr] ptr to the root of the metaschema in the jsi_document
+    include(Base::Immutable)
+
+    # @param jsi_document the document containing the meta-schema.
+    #   this must be frozen recursively; MetaSchemaNode does support mutation.
+    # @param jsi_ptr [JSI::Ptr] ptr to this MetaSchemaNode in jsi_document
+    # @param schema_implementation_modules [Enumerable<Module>] modules which implement the functionality
+    #   of the schema. These are included on the {Schema#jsi_schema_module} of the meta-schema.
+    #   They extend any schema described by the meta-schema, including those in the document containing
+    #   the meta-schema, and the meta-schema itself.
+    #   see {Schema#describes_schema!} param `schema_implementation_modules`.
+    # @param metaschema_root_ptr [JSI::Ptr] ptr to the root of the meta-schema in the jsi_document
     # @param root_schema_ptr [JSI::Ptr] ptr to the schema describing the root of the jsi_document
     def initialize(
         jsi_document,
         jsi_ptr: Ptr[],
-        metaschema_instance_modules: ,
+        schema_implementation_modules: ,
         metaschema_root_ptr: Ptr[],
         root_schema_ptr: Ptr[],
-        jsi_schema_base_uri: nil
+        jsi_schema_base_uri: nil,
+        jsi_schema_registry: nil,
+        jsi_content_to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE,
+        jsi_root_node: nil
     )
-      jsi_initialize_memos
+      super(jsi_document,
+        jsi_ptr: jsi_ptr,
+        jsi_indicated_schemas: SchemaSet[],
+        jsi_schema_base_uri: jsi_schema_base_uri,
+        jsi_schema_registry: jsi_schema_registry,
+        jsi_content_to_immutable: jsi_content_to_immutable,
+        jsi_root_node: jsi_root_node,
+      )
 
-      self.jsi_document = jsi_document
-      self.jsi_ptr = jsi_ptr
-      @metaschema_instance_modules = Util.ensure_module_set(metaschema_instance_modules)
+      @schema_implementation_modules = schema_implementation_modules = Util.ensure_module_set(schema_implementation_modules)
       @metaschema_root_ptr = metaschema_root_ptr
       @root_schema_ptr = root_schema_ptr
 
       if jsi_ptr.root? && jsi_schema_base_uri
-        raise(NotImplementedError, "unsupported jsi_schema_base_uri on metaschema document root")
+        raise(NotImplementedError, "unsupported jsi_schema_base_uri on meta-schema document root")
       end
-      self.jsi_schema_base_uri = jsi_schema_base_uri
 
-      jsi_node_content = self.jsi_node_content
+      #chkbug raise(Bug, 'MetaSchemaNode instance must be frozen') unless jsi_node_content.frozen?
 
-      if jsi_node_content.respond_to?(:to_hash)
-        extend PathedHashNode
-      end
-      if jsi_node_content.respond_to?(:to_ary)
-        extend PathedArrayNode
-      end
+      extends = Set[]
 
       instance_for_schemas = jsi_document
-      bootstrap_schema_class = JSI::SchemaClasses.bootstrap_schema_class(metaschema_instance_modules)
+      bootstrap_schema_class = JSI::SchemaClasses.bootstrap_schema_class(schema_implementation_modules)
       root_bootstrap_schema = bootstrap_schema_class.new(
         jsi_document,
         jsi_ptr: root_schema_ptr,
         jsi_schema_base_uri: nil, # supplying jsi_schema_base_uri on root bootstrap schema is not supported
       )
-      our_bootstrap_schemas = jsi_ptr.tokens.inject(SchemaSet[root_bootstrap_schema]) do |bootstrap_schemas, tok|
-        child_instance_for_schemas = instance_for_schemas[tok]
-        bootstrap_schemas_for_instance = SchemaSet.build do |schemas|
-          bootstrap_schemas.each do |bootstrap_schema|
-            bootstrap_schema.each_child_applicator_schema(tok, instance_for_schemas) do |child_app_schema|
-              child_app_schema.each_inplace_applicator_schema(child_instance_for_schemas) do |child_inpl_app_schema|
-                schemas << child_inpl_app_schema
-              end
-            end
-          end
-        end
-        instance_for_schemas = child_instance_for_schemas
-        bootstrap_schemas_for_instance
+      our_bootstrap_indicated_schemas = jsi_ptr.tokens.inject(SchemaSet[root_bootstrap_schema]) do |bootstrap_indicated_schemas, tok|
+        bootstrap_schemas = bootstrap_indicated_schemas.inplace_applicator_schemas(instance_for_schemas)
+        child_indicated_schemas = bootstrap_schemas.child_applicator_schemas(tok, instance_for_schemas)
+        instance_for_schemas = instance_for_schemas[tok]
+        child_indicated_schemas
       end
+      @indicated_schemas_map = jsi_memomap { bootstrap_schemas_to_msn(our_bootstrap_indicated_schemas) }
+
+      our_bootstrap_schemas = our_bootstrap_indicated_schemas.inplace_applicator_schemas(instance_for_schemas)
 
+      describes_self = false
       our_bootstrap_schemas.each do |bootstrap_schema|
         if bootstrap_schema.jsi_ptr == metaschema_root_ptr
-          metaschema_instance_modules.each do |metaschema_instance_module|
-            extend metaschema_instance_module
+          # this is described by the meta-schema, i.e. this is a schema
+          extend Schema
+          schema_implementation_modules.each do |schema_implementation_module|
+            extend schema_implementation_module
           end
+          extends += schema_implementation_modules
         end
         if bootstrap_schema.jsi_ptr == jsi_ptr
-          extend Metaschema
-          self.jsi_schema_instance_modules = metaschema_instance_modules
+          # this is the meta-schema (it is described by itself)
+          describes_self = true
         end
       end
 
-      @jsi_schemas = SchemaSet.new(our_bootstrap_schemas) do |bootstrap_schema|
-        if bootstrap_schema.jsi_ptr == jsi_ptr
-          self
-        else
-          new_node(
-            jsi_ptr: bootstrap_schema.jsi_ptr,
-            jsi_schema_base_uri: bootstrap_schema.jsi_schema_base_uri,
-          )
-        end
+      @jsi_schemas = bootstrap_schemas_to_msn(our_bootstrap_schemas)
+
+      # note: jsi_schemas must already be set for jsi_schema_module to be used/extended
+      if describes_self
+        describes_schema!(schema_implementation_modules)
       end
 
-      @jsi_schemas.each do |schema|
-        extend schema.jsi_schema_module
+      extends_for_instance = JSI::SchemaClasses.includes_for(jsi_node_content)
+      extends.merge(extends_for_instance)
+      extends.freeze
+
+      conflicting_modules = Set[self.class] + extends + @jsi_schemas.map(&:jsi_schema_module)
+      reader_modules = @jsi_schemas.map do |schema|
+        JSI::SchemaClasses.schema_property_reader_module(schema, conflicting_modules: conflicting_modules)
       end
 
-      # workarounds
-      begin # draft 4 boolean schema workaround
-        # in draft 4, boolean schemas are not described in the root, but on anyOf schemas on
-        # properties/additionalProperties and properties/additionalItems.
-        # since these describe schemas, their jsi_schema_instance_modules are the metaschema_instance_modules.
-        addtlPropsanyOf = metaschema_root_ptr["properties"]["additionalProperties"]["anyOf"]
-        addtlItemsanyOf = metaschema_root_ptr["properties"]["additionalItems"]["anyOf"]
+      readers = reader_modules.map(&:jsi_property_readers).inject(Set[], &:merge).freeze
+      define_singleton_method(:jsi_property_readers) { readers }
 
-        if !jsi_ptr.root? && [addtlPropsanyOf, addtlItemsanyOf].include?(jsi_ptr.parent)
-          self.jsi_schema_instance_modules = metaschema_instance_modules
-        end
+      reader_modules.each { |reader_module| extend reader_module }
+
+      extends_for_instance.each do |m|
+        extend m
+      end
+
+      @jsi_schemas.each do |schema|
+        extend schema.jsi_schema_module
       end
     end
 
-    # Set of modules to apply to schemas which are instances of (described by) the metaschema
+    # Set of modules to apply to schemas that are instances of (described by) the meta-schema
     # @return [Set<Module>]
-    attr_reader :metaschema_instance_modules
+    attr_reader :schema_implementation_modules
 
-    # ptr to the root of the metaschema in the jsi_document
+    # ptr to the root of the meta-schema in the jsi_document
     # @return [JSI::Ptr]
     attr_reader :metaschema_root_ptr
 
@@ -136,110 +142,132 @@ module JSI
     # @return [JSI::Ptr]
     attr_reader :root_schema_ptr
 
-    # JSI Schemas describing this MetaschemaNode
+    # JSI Schemas describing this MetaSchemaNode
     # @return [JSI::SchemaSet]
     attr_reader :jsi_schemas
 
-    # document root MetaschemaNode
-    # @return [MetaschemaNode]
-    def jsi_root_node
-      if jsi_ptr.root?
-        self
-      else
-        new_node(
-          jsi_ptr: Ptr[],
-          jsi_schema_base_uri: nil,
-        )
-      end
+    # See {Base#jsi_indicated_schemas}
+    # @return [JSI::SchemaSet]
+    def jsi_indicated_schemas
+      @indicated_schemas_map[]
     end
 
-    # parent MetaschemaNode
-    # @return [MetaschemaNode]
-    def jsi_parent_node
-      jsi_ptr.parent.evaluate(jsi_root_node)
-    end
+    # see {Base#jsi_child}
+    def jsi_child(token, as_jsi: )
+      child_node = @root_descendent_node_map[ptr: jsi_ptr[token]]
 
-    # subscripts to return a child value identified by the given token.
-    #
-    # @param token (see JSI::Base#[])
-    # @param as_jsi (see JSI::Base#[])
-    # @return (see JSI::Base#[])
-    def [](token, as_jsi: :auto)
-      if respond_to?(:to_hash)
-        token_in_range = jsi_node_content_hash_pubsend(:key?, token)
-        value = jsi_node_content_hash_pubsend(:[], token)
-      elsif respond_to?(:to_ary)
-        token_in_range = jsi_node_content_ary_pubsend(:each_index).include?(token)
-        value = jsi_node_content_ary_pubsend(:[], token)
-      else
-        raise(NoMethodError, "cannot subscript (using token: #{token.inspect}) from content: #{jsi_node_content.pretty_inspect.chomp}")
+      jsi_child_as_jsi(child_node.jsi_node_content, child_node.jsi_schemas, as_jsi) do
+        child_node
       end
+    end
+    private :jsi_child
 
-      begin
-        if token_in_range
-          value_node = jsi_subinstance_memos[token]
-
-          jsi_subinstance_as_jsi(value, value_node.jsi_schemas, as_jsi) do
-            value_node
-          end
-        else
-          # I think I will not support Hash#default/#default_proc in this case.
-          nil
-        end
-      end
+    # See {Base#jsi_default_child}
+    def jsi_default_child(token, as_jsi: )
+      jsi_node_content_child(token)
     end
+    private :jsi_default_child # internals for #[] but idk, could be public
 
-    # instantiates a new MetaschemaNode whose instance is a modified copy of this MetaschemaNode's instance
+    # instantiates a new MetaSchemaNode whose instance is a modified copy of this MetaSchemaNode's instance
     # @yield [Object] the node content of the instance. the block should result
     #   in a (nondestructively) modified copy of this.
-    # @return [MetaschemaNode] modified copy of self
+    # @return [MetaSchemaNode] modified copy of self
     def jsi_modified_copy(&block)
-      MetaschemaNode.new(jsi_ptr.modified_document_copy(jsi_document, &block), **our_initialize_params)
+      if jsi_ptr.root?
+        modified_document = jsi_ptr.modified_document_copy(jsi_document, &block)
+        modified_document = jsi_content_to_immutable.call(modified_document) if jsi_content_to_immutable
+        MetaSchemaNode.new(modified_document, **our_initialize_params)
+      else
+        modified_jsi_root_node = jsi_root_node.jsi_modified_copy do |root|
+          jsi_ptr.modified_document_copy(root, &block)
+        end
+        modified_jsi_root_node.jsi_descendent_node(jsi_ptr)
+      end
     end
 
     # @private
     # @return [Array<String>]
     def jsi_object_group_text
       if jsi_schemas && jsi_schemas.any?
-        class_n_schemas = "#{self.class} (#{jsi_schemas.map { |s| s.jsi_ptr.uri }.join(' ')})"
+        class_n_schemas = -"#{self.class} (#{jsi_schemas.map { |s| s.jsi_schema_module.name_from_ancestor || s.jsi_ptr.uri }.join(' ')})"
       else
         class_n_schemas = self.class.to_s
       end
       [
         class_n_schemas,
-        is_a?(Metaschema) ? "Metaschema" : is_a?(Schema) ? "Schema" : nil,
-        *(jsi_node_content.respond_to?(:jsi_object_group_text) ? jsi_node_content.jsi_object_group_text : []),
-      ].compact
+        is_a?(Schema::MetaSchema) ? "Meta-Schema" : is_a?(Schema) ? "Schema" : nil,
+        *(jsi_node_content.respond_to?(:jsi_object_group_text) ? jsi_node_content.jsi_object_group_text : nil),
+      ].compact.freeze
     end
 
-    # an opaque fingerprint of this MetaschemaNode for FingerprintHash
+    # see {Util::Private::FingerprintHash}
+    # @api private
     def jsi_fingerprint
-      {class: self.class, jsi_document: jsi_document}.merge(our_initialize_params)
+      {class: self.class, jsi_document: jsi_document}.merge(our_initialize_params).freeze
     end
 
+    protected
+
+    attr_reader :root_descendent_node_map
+
     private
 
+    def jsi_memomaps_initialize
+      if jsi_ptr.root?
+        @root_descendent_node_map = jsi_memomap(&method(:jsi_root_descendent_node_compute))
+      else
+        @root_descendent_node_map = @jsi_root_node.root_descendent_node_map
+      end
+    end
+
+    # note: does not include jsi_root_node
     def our_initialize_params
       {
         jsi_ptr: jsi_ptr,
-        metaschema_instance_modules: metaschema_instance_modules,
+        schema_implementation_modules: schema_implementation_modules,
         metaschema_root_ptr: metaschema_root_ptr,
         root_schema_ptr: root_schema_ptr,
         jsi_schema_base_uri: jsi_schema_base_uri,
-      }
+        jsi_schema_registry: jsi_schema_registry,
+        jsi_content_to_immutable: jsi_content_to_immutable,
+      }.freeze
     end
 
-    def new_node(params)
-      MetaschemaNode.new(jsi_document, **our_initialize_params.merge(params))
+    # note: not for root node
+    def new_node(**params)
+      MetaSchemaNode.new(jsi_document, jsi_root_node: jsi_root_node, **our_initialize_params, **params)
     end
 
-    def jsi_subinstance_memos
-      jsi_memomap(:subinstance) do |token|
+    def jsi_root_descendent_node_compute(ptr: )
+      #chkbug raise(Bug) unless jsi_ptr.root?
+      if ptr.root?
+        self
+      else
         new_node(
-          jsi_ptr: jsi_ptr[token],
+          jsi_ptr: ptr,
           jsi_schema_base_uri: jsi_resource_ancestor_uri,
         )
       end
     end
+
+    # @param bootstrap_schemas [Enumerable<BootstrapSchema>]
+    # @return [SchemaSet<MetaSchemaNode>]
+    def bootstrap_schemas_to_msn(bootstrap_schemas)
+      SchemaSet.new(bootstrap_schemas) do |bootstrap_schema|
+        if bootstrap_schema.jsi_ptr == jsi_ptr
+          self
+        elsif bootstrap_schema.jsi_ptr.root?
+          @jsi_root_node
+        else
+          new_node(
+            jsi_ptr: bootstrap_schema.jsi_ptr,
+            jsi_schema_base_uri: bootstrap_schema.jsi_schema_base_uri,
+          )
+        end
+      end
+    end
   end
+
+  # @deprecated after v0.7.0, alias of {MetaSchemaNode}
+  MetaschemaNode = MetaSchemaNode
 end