metanorma-document 0.5.1 → 0.5.2.pre.alpha.1

data/lib/metanorma/document/mko.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "metanorma/mko"
+require "metanorma-core"
+require "nokogiri"
+
+module Metanorma
+  # The MODEL side of MKO (MN 116), reopening the format gem's module:
+  # the projection walk (Project), collection orchestration
+  # (Collection), the compile-pipeline exporter, flavor resolution and
+  # registry seeding, and the export entry points. The wire contract —
+  # schema, bundle layout, assets, diffs, alignment, JSON Schemas, the
+  # MCP server — lives in the metanorma-mko gem.
+  module Mko
+    autoload :Project, "metanorma/document/mko/project"
+    autoload :Collection, "metanorma/document/mko/collection"
+    autoload :Exporter, "metanorma/document/mko/exporter"
+
+    class << self
+      # Export a document model (or semantic/presentation XML string)
+      # as an MKO bundle directory (or .mko.zip with zip: true).
+      # Returns an Export (path + projection Result); the Export
+      # ducktypes as the bundle path String for existing callers.
+      def export(source, to:, presentation_xml: nil, zip: false,
+                 assets_from: nil)
+        seed_flavors!
+        model = source.is_a?(String) ? model_from_xml(source) : source
+        presentation = case presentation_xml
+                       when String then model_from_xml(presentation_xml)
+                       when nil then nil
+                       else presentation_xml
+                       end
+        projection = Project.call(model, presentation: presentation,
+                                         assets: Assets.new(source_dir: assets_from))
+        Export.new(Writer.write(projection, to: to, zip: zip), projection)
+      end
+
+      # The format adapter over the central flavor registry (mirrors
+      # Html::Generator): a flavor entry may register its own :mko
+      # renderer; with none, the harness Exporter serves any model tree
+      # — the walk is class/attribute-driven, zero flavor knowledge.
+      def generate(document, **)
+        seed_flavors!
+        renderer_for(document, **)
+          .new.generate_full_document(document, **)
+      end
+
+      def renderer_for(document, **)
+        seed_flavors!
+        Metanorma::Core::Flavors.renderer_for(document, format: :mko,
+                                                        **) || Exporter
+      end
+
+      private
+
+      def model_from_xml(xml)
+        root = Nokogiri::XML(xml).root
+        flavor = root["flavor"]
+        klass = nil
+        Metanorma::Core::Flavors.table.reverse_each do |entry|
+          next if entry.taste?
+
+          candidate = entry.model_root_class or next
+          name = entry.name.to_s
+          next if flavor && !flavor.empty? && name != flavor
+
+          klass = candidate
+          break
+        end
+        unless klass
+          raise ArgumentError,
+                "no document model registered for flavor #{flavor.inspect}; " \
+                "require the flavor gem (metanorma-standoc or a flavor) " \
+                "before exporting"
+        end
+
+        klass.from_xml(xml)
+      end
+    end
+
+    # Same seeding pattern as Html in html.rb: contribute the mko
+    # renderer for the two harness model trees. Flavor models do not
+    # subclass the harness roots (they include RootAttributes), so
+    # renderer resolution for :mko goes through .renderer_for below with
+    # a harness fallback — the Html::Generator pattern. Core::Flavors
+    # has no add_renderer API yet — attach to the entry html.rb
+    # registered when present, register a standalone entry otherwise
+    # (mko loaded without html); delete the attach branch when core
+    # gains the mutator.
+    SEED_MODEL_ROOTS = {
+      document: Metanorma::Document::Root,
+      standoc: "Metanorma::Standoc::Document::Root",
+    }.freeze
+
+    # Lazy: seeding touches the core flavor registry, which only the
+    # flavor-table line of metanorma-core defines. Requiring this gem
+    # must never depend on it — seeds on first use, no-op without it.
+    class << self
+      def seed_flavors!
+        return unless defined?(Metanorma::Core::Flavors)
+        return if @flavors_seeded
+
+        @flavors_seeded = true
+        SEED_MODEL_ROOTS.each do |seed, model_root|
+          entry = Metanorma::Core::Flavors.find(seed)
+          if entry
+            entry.renderers[:mko] ||= Exporter
+          else
+            Metanorma::Core::Flavors.register(Metanorma::Core::Flavor.new(
+                                                name: seed,
+                                                model_root: model_root,
+                                                renderers: { mko: Exporter },
+                                              ))
+          end
+        end
+      end
+    end
+  end
+
+  # document.rb keeps the lazy entry that pulls the model side in
+  Document.autoload :MkoIntegration, "metanorma/document/mko" if false
+end

data/lib/metanorma/document/model_access.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Document
+    # Attribute-keyed access to typed model objects — the one shared
+    # vocabulary for walking both model trees. Flavor classes may omit
+    # attributes the base trees carry (or rename them), so every read
+    # is keyed on the class's lutaml declarations, never on
+    # respond_to?. Included by the model-layer decomposition
+    # (NativeModels) and the MKO projection alike.
+    module ModelAccess
+      # The attribute's value, or nil when the object does not declare
+      # the attribute (or is not a typed model object at all).
+      def val(obj, name)
+        return nil unless serializable?(obj)
+
+        obj.class.attributes.key?(name) ? obj.public_send(name) : nil
+      end
+
+      # Collection form: always an Array.
+      def vals(obj, name)
+        Array(val(obj, name))
+      end
+
+      def serializable?(obj)
+        obj.is_a?(Lutaml::Model::Serializable)
+      end
+
+      # A bibdata's document identifiers; flavor trees rename the
+      # attribute (:docidentifier vs :doc_identifier).
+      def docids(bib)
+        out = vals(bib, :docidentifier)
+        out = vals(bib, :doc_identifier) if out.empty?
+        out.compact
+      end
+
+      # The identifier's text: the base tree maps content to :id; iso
+      # declares :value.
+      def docid_text(docid)
+        val(docid, :id) || val(docid, :value)
+      end
+    end
+  end
+end

data/lib/metanorma/document/native_models.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "glossarist"
+require "relaton/bib"
+require "pubid"
+
+module Metanorma
+  module Document
+    # Decomposition of a typed document model into the native object
+    # models of the Metanorma ecosystem: Glossarist concepts from term
+    # entries, Relaton bibdata from the bibliographic record, Pubid
+    # identifiers from document identifiers.
+    #
+    # This is a MODEL-layer capability, available to any consumer; the
+    # MKO serialization is one of them. All objects returned are the
+    # native gems' own classes, serialized by their own frameworks —
+    # never re-flattened into a parallel schema. Traversal dispatches on
+    # class/attribute declarations only (both model trees; zero flavor
+    # knowledge).
+    module NativeModels
+      class << self
+        include Metanorma::Document::ModelAccess
+
+        # Term entries as Glossarist::Concept objects (native to_json).
+        # lang/date are derivable defaults, overridable by callers that
+        # already computed them.
+        def glossarist_concepts(root, lang: nil, date: nil)
+          lang ||= first_lang(root)
+          date ||= published_on(root)
+          entries(root).map do |term|
+            concept_for(term, lang: lang, date: date)
+          end
+        end
+
+        # The bibliographic record as a native Relaton::Bib item. The
+        # model's bibdata is serialized to Relaton XML (its native
+        # schema) and parsed back by the relaton monogem — both
+        # directions are framework serialization.
+        def relaton_bibdata(root)
+          bib = val(root, :bibdata)
+          return nil unless bib
+
+          ::Relaton::Bib::Item.from_xml(bib.to_xml)
+        end
+
+        # Document identifiers parsed by the pubid monogem. Each entry
+        # carries the original text, its primary flag, and the native
+        # Pubid::Identifier (nil when no pubid flavor covers it).
+        def pubid_identifiers(root)
+          bib = val(root, :bibdata)
+          docids(bib).map do |d|
+            text = docid_text(d)
+            { original: text, type: val(d, :type),
+              primary: val(d, :primary), pubid: parse_pubid(text) }
+          end
+        end
+
+        # One bibliography entry: the reference unit's key, the citeas
+        # string, and the NATIVE objects behind the cited document — a
+        # Relaton::Bib item and, when a pubid flavor covers it, a
+        # Pubid::Identifier. This is what makes citation edges resolvable
+        # objects instead of dangling strings.
+        class BibliographyEntry
+          attr_reader :key, :citeas, :pubid, :item
+
+          def initialize(key:, citeas:, pubid:, item:)
+            @key = key
+            @citeas = citeas
+            @pubid = pubid
+            @item = item
+          end
+        end
+
+        # Bibliography entries as native Relaton items. Every <bibitem>
+        # in every references section round-trips: model XML (the
+        # Relaton schema) parsed back by the relaton monogem.
+        def relaton_bibliography(root)
+          entries = []
+          Array(val(root, :bibliography)).each do |bib_section|
+            vals(bib_section, :references).each do |refs|
+              items = vals(refs, :bibitem)
+              items = vals(refs, :references) if items.empty?
+              items.each { |i| entries << bibliography_entry(i) }
+            end
+          end
+          entries
+        end
+
+        def bibliography_entry(item)
+          key = val(item, :anchor) || val(item, :id)
+          citeas = docid_text(vals(item, :docidentifier).first) ||
+            PlainText.call(val(item, :formatted_ref))
+          BibliographyEntry.new(
+            key: key, citeas: citeas,
+            pubid: parse_pubid(citeas),
+            item: begin
+              ::Relaton::Bib::Item.from_xml(item.to_xml)
+            rescue StandardError
+              nil
+            end
+          )
+        end
+
+        # A content block's native JSON object: the Mirror node tree —
+        # the lossless JSON serialization this gem's JS ecosystem
+        # renders from (same handlers the to-mirror CLI uses). This is
+        # the blocks' native serialization; the lutaml key-value path
+        # cannot serialize content blocks on 0.8.x.
+        def mirror_object(block)
+          transformer = ::Metanorma::Mirror::Transformer.new
+          result = ::Metanorma::Mirror.default_registry.handle(
+            block, context: transformer
+          )
+          Array(result.nodes).each do |node|
+            parsed = JSON.parse(
+              ::Metanorma::Mirror::Serialization::JsonSerializer
+                .serialize(node),
+            )
+            return parsed if parsed.is_a?(Hash)
+          end
+          nil
+        rescue StandardError
+          nil
+        end
+
+        # Parsed identity [series, number, part] via the native pubid
+        # parse — the single identity parser. OIML's series letter
+        # lives in the pubid type (recommendation → R, document → D,
+        # basic publication → B, guide → G, expert report → E,
+        # vocabulary → V); publishers without a series letter (ISO,
+        # IEC) yield nil series. Returns nil when no flavor covers the
+        # identifier — callers fall back, never guess.
+        OIML_SERIES = {
+          "recommendation" => "R", "document" => "D",
+          "basic-publication" => "B", "basic_publication" => "B",
+          "guide" => "G", "expert-report" => "E", "expert_report" => "E",
+          "vocabulary" => "V"
+        }.freeze
+
+        def pubid_identity(text)
+          pubid = parse_pubid(text)
+          return nil unless pubid
+
+          native = JSON.parse(pubid.to_json)
+          series = if native["_type"].to_s.start_with?("pubid:oiml:")
+                     OIML_SERIES[native["_type"].split(":").last]
+                   end
+          [series, native["number"]&.to_s, native["part"]&.to_s]
+        end
+
+        # Formula as a native Plurimath::Math::Formula. Plurimath is the
+        # Metanorma math ecosystem: parse from the stem's AsciiMath, or
+        # from its MathML (the mml model's own XML serialization) when
+        # only that is present. Plurimath 0.11 has no data-producing
+        # to_json — its native serializations are the to_* forms
+        # (asciimath, latex, mathml, omml, unicodemath), which is what
+        # consumers get.
+        def plurimath_formula(formula_block)
+          require "plurimath"
+          stem = val(formula_block, :stem)
+          return nil unless stem
+
+          expr = val(stem, :asciimath)&.value
+          unless expr.to_s.empty?
+            return Plurimath::Math.parse(expr.to_s, :asciimath)
+          end
+
+          math = val(stem, :math)
+          Plurimath::Math.parse(math.to_xml, :mathml) if math
+        rescue StandardError, LoadError
+          nil
+        end
+        # "OIML" engages the day the flavor ships (pubid/pubid#342);
+        # until then Pubid::Oiml is undefined and parses nil.
+        PUBID_FLAVORS = {
+          "ISO" => :Iso, "IEC" => :Iec, "ITU" => :Itu, "BSI" => :Bsi,
+          "BS" => :Bsi, "OGC" => :Ogc, "NIST" => :Nist, "IEEE" => :Ieee,
+          "OIML" => :Oiml
+        }.freeze
+
+        # ISO 639-1 → 639-2/B for Glossarist language codes.
+        GLOSSARIST_LANG = {
+          "en" => "eng", "fr" => "fre", "de" => "ger", "es" => "spa",
+          "ar" => "ara", "ru" => "rus", "zh" => "zho", "ja" => "jpn",
+          "ko" => "kor"
+        }.freeze
+
+        private
+
+        # -- publisher → pubid flavor --------------------------------
+
+        def parse_pubid(text)
+          return nil if text.nil? || text.empty?
+
+          flavor = PUBID_FLAVORS[text[/\A([A-Za-z]+)/, 1].to_s.upcase]
+          return nil unless flavor
+
+          Pubid.const_get(flavor).parse(text)
+        rescue StandardError
+          nil
+        end
+
+        # -- glossarist construction ---------------------------------
+
+        def concept_for(term, lang:, date:)
+          g_lang = GLOSSARIST_LANG.fetch(lang, lang)
+          designations = vals(term, :preferred)
+            .map { |d| PlainText.call(d) }.reject(&:empty?)
+          admitted = vals(term, :admitted)
+            .map { |d| PlainText.call(d) }.reject(&:empty?)
+          deprecated = vals(term, :deprecates)
+            .map { |d| PlainText.call(d) }.reject(&:empty?)
+          definition = PlainText.call(val(term, :definition))
+          sources = vals(term, :source).filter_map do |src|
+            citeas = begin
+              vals(src, :origin).first&.citeas
+            rescue StandardError
+              nil
+            end
+            citeas = PlainText.call(citeas) if citeas
+            if citeas && !citeas.empty?
+              Glossarist::ConceptSource.new(
+                type: "authoritative",
+                origin: { "ref" => { "source" => citeas } },
+              )
+            end
+          end
+          dates = if date
+                    [Glossarist::ConceptDate.new(
+                      date: date, type: "accepted",
+                    )]
+                  else
+                    []
+                  end
+          Glossarist::Concept.new(
+            id: anchor_of(term),
+            data: Glossarist::ConceptData.new(
+              id: "#{anchor_of(term)}-#{g_lang}",
+              language_code: g_lang,
+              terms: [
+                ["preferred", designations],
+                ["admitted", admitted],
+                ["deprecated", deprecated],
+              ].flat_map do |status, terms|
+                terms.map do |designation|
+                  Glossarist::Designation::Expression.new(
+                    designation: designation, normative_status: status,
+                  )
+                end
+              end,
+              definition: [Glossarist::DetailedDefinition.new(
+                content: definition,
+              )],
+              sources: sources,
+              dates: dates,
+              entry_status: "valid",
+            ),
+          )
+        end
+
+        # -- term-entry traversal (both trees) -----------------------
+        #
+        # The iso tree declares entries as :term inside terms sections;
+        # the standoc tree maps them to :terms. Terms sections are
+        # recognizable by the :term declaration.
+
+        def entries(root)
+          out = []
+          collect_entries(val(root, :sections), out)
+          collect_entries(val(root, :preface), out)
+          # amendments keep their terms in annexes (e.g. OIML R 60/A1)
+          vals(root, :annex).each { |a| collect_entries(a, out) }
+          out
+        end
+
+        def collect_entries(container, out)
+          return unless container
+
+          vals(container, :terms).each do |tsec|
+            term_entries(tsec).each { |t| out << t }
+            vals(tsec, :terms).each { |nested| collect_terms(nested, out) }
+          end
+          vals(container, :clause).each { |c| collect_entries(c, out) }
+          vals(container, :subsections).each { |c| collect_entries(c, out) }
+        end
+
+        def collect_terms(tsec, out)
+          term_entries(tsec).each { |t| out << t }
+          vals(tsec, :terms).each { |nested| collect_terms(nested, out) }
+        end
+
+        def term_entries(tsec)
+          entries_ = vals(tsec, :term)
+          entries_ = vals(tsec, :terms) if entries_.empty?
+          entries_
+        end
+
+        def anchor_of(element)
+          anchor = val(element, :anchor)
+          return anchor if anchor && !anchor.empty?
+
+          id = val(element, :id)
+          id && !id.empty? ? id : nil
+        end
+
+        def first_lang(root)
+          bib = val(root, :bibdata)
+          PlainText.call(vals(bib, :language).first).to_s[0, 2]
+        end
+
+        def published_on(root)
+          bib = val(root, :bibdata)
+          vals(bib, :date).filter_map { |d| PlainText.call(val(d, :on)) }
+            .first
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/document/plain_text.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Document
+    # Extracts plain display text from typed model elements. Delegates to
+    # the canonical model-walking extractor shared with the HTML renderer
+    # (element_order resolution + typed attributes) — never Nokogiri over
+    # XML, never regex over HTML.
+    module PlainText
+      class Extractor
+        include Metanorma::Html::Concerns::TextExtraction
+
+        def safe_attr(obj, name)
+          return nil unless obj.is_a?(Lutaml::Model::Serializable) &&
+            obj.class.attributes.key?(name)
+
+          obj.public_send(name)
+        end
+      end
+
+      EXTRACTOR = Extractor.new
+
+      class << self
+        # Whitespace-squashed on the way out: document text carries
+        # non-breaking spaces (U+00A0) that break exact matching; Ruby's
+        # \s is ASCII-only, so use the Unicode-aware POSIX class.
+        def call(element)
+          return squash(EXTRACTOR.extract_plain_text(element).to_s) unless element.is_a?(Array)
+
+          element.map { |e| call(e) }.reject(&:empty?).join(" ")
+        end
+
+        def squash(text)
+          text.gsub(/[[:space:]]+/, " ").strip
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/document/relaton/version_info.rb

@@ -12,11 +12,15 @@ module Metanorma
       class VersionInfo < Lutaml::Model::Serializable
         attribute :revision_date, :string
         attribute :draft, :string
+        # Legacy presentation XML states the version as bare text
+        # (<version>2018-01-17</version>), e.g. the BIPM draft date.
+        attribute :content, :string
 
         xml do
           element "version"
           map_element "revision-date", to: :revision_date
           map_element "draft", to: :draft
+          map_content to: :content
         end
       end
     end

data/lib/metanorma/document/version.rb

@@ -2,7 +2,7 @@
 
 module Metanorma
   module Document
-    VERSION = "0.5.1"
+    VERSION = "0.5.2.pre.alpha.1"
     Version = VERSION
   end
 end

data/lib/metanorma/document.rb

@@ -16,8 +16,16 @@ module Metanorma
   # for a seamless migration from/to those.
   module Document
     autoload :Components, "metanorma/document/components"
+    # Mirror: the format lives in the metanorma-mirror gem; this gem
+    # registers its model knowledge (handlers, mark tables, id
+    # categories) through the gem's seams.
+    autoload :MirrorSeed, "metanorma/document/mirror_seed"
     autoload :DataTypes, "metanorma/document/data_types"
     autoload :Elements, "metanorma/document/elements"
+    autoload :GrammarVocabulary, "metanorma/document/grammar_vocabulary"
+    autoload :ModelAccess, "metanorma/document/model_access"
+    autoload :NativeModels, "metanorma/document/native_models"
+    autoload :PlainText, "metanorma/document/plain_text"
     autoload :Relaton, "metanorma/document/relaton"
     autoload :Root, "metanorma/document/root"
     autoload :Version, "metanorma/document/version"
@@ -30,37 +38,22 @@ module Metanorma
       # For now, we cannot parse arbitrary XML into Lutaml models without knowing
       # the target class. This will be addressed in a future refactoring.
       # BasicDocument does not have XML root mapping and cannot be used to parse
-      # documents directly. Use StandardDocument or IsoDocument for specific flavors.
+      # documents directly. Use a flavor document model for specific flavors.
       raise NotImplementedError,
             "BasicDocument cannot parse XML directly. " \
-            "Use StandardDocument or IsoDocument for specific document flavors, " \
-            "or implement a custom parser that determines the appropriate document class."
+            "Use a flavor document model (e.g. Metanorma::Standoc::Document::Root " \
+            "from metanorma-standoc), or implement a custom parser."
     end
   end
 
   autoload :BasicDocument, "#{__dir__}/basic_document"
-  autoload :StandardDocument, "metanorma/standard_document"
-  autoload :IsoDocument, "metanorma/iso_document"
-  autoload :IecDocument, "metanorma/iec_document"
-  autoload :IeeeDocument, "metanorma/ieee_document"
-  autoload :IetfDocument, "metanorma/ietf_document"
-  autoload :IhoDocument, "metanorma/iho_document"
-  autoload :CcDocument, "metanorma/cc_document"
-  autoload :CsaDocument, "metanorma/csa_document"
-  autoload :BipmDocument, "metanorma/bipm_document"
-  autoload :BsiDocument, "metanorma/bsi_document"
-  autoload :GbDocument, "metanorma/gb_document"
-  autoload :GenericDocument, "metanorma/generic_document"
-  autoload :ItuDocument, "metanorma/itu_document"
-  autoload :JisDocument, "metanorma/jis_document"
-  autoload :M3dDocument, "metanorma/m3d_document"
-  autoload :NistDocument, "metanorma/nist_document"
-  autoload :OgcDocument, "metanorma/ogc_document"
-  autoload :PlateauDocument, "metanorma/plateau_document"
-  autoload :Registers, "metanorma/registers"
-  autoload :RiboseDocument, "metanorma/ribose_document"
-  autoload :UnDocument, "metanorma/un_document"
-  autoload :Collection, "metanorma/collection"
+  autoload :DocumentCollection, "metanorma/document_collection"
   autoload :Html, "metanorma/html"
-  autoload :Mirror, "metanorma/mirror"
+  # Mko: the format lives in the metanorma-mko gem; Metanorma::Mko is
+  # REOPENED by the model side (document/mko.rb) with the projection
+  # walk and export entry points.
+  autoload :Mko, "metanorma/document/mko"
 end
+
+require "metanorma/mirror"
+Metanorma::Document::MirrorSeed.register

data/lib/metanorma/{collection → document_collection}/directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Metanorma
-  module Collection
+  module DocumentCollection
     # A key-value directive in a metanorma-collection.
     # Directives control collection behavior (e.g., documents-inline, flavor).
     class Directive < Lutaml::Model::Serializable

data/lib/metanorma/{collection → document_collection}/doc_container.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 module Metanorma
-  module Collection
+  module DocumentCollection
     # A container for an embedded document within a metanorma-collection.
     # Each doc-container holds one <metanorma> document identified by its id attribute.
     class DocContainer < Lutaml::Model::Serializable
       attribute :id, :string
-      attribute :document, Metanorma::IsoDocument::Root
+      # Embedded documents belong to whichever flavor authored them; the
+      # harness carries only the neutral base root. Flavor-faithful parsing
+      # arrives with lutaml polymorphic differentiators (subclass roots
+      # declaring polymorphic_class: true), not by typing against a flavor.
+      attribute :document, Metanorma::Document::Root
 
       xml do
         element "doc-container"

data/lib/metanorma/{collection → document_collection}/entry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Metanorma
-  module Collection
+  module DocumentCollection
     # An entry in a metanorma-collection manifest.
     # Entries are recursive — a top-level entry can contain nested entries,
     # each representing a document in the collection.
@@ -13,7 +13,7 @@ module Metanorma
       attribute :type, :string
       attribute :title, :string
       attribute :format, :string, collection: true
-      attribute :bibdata, Metanorma::IsoDocument::Metadata::IsoBibliographicItem
+      attribute :bibdata, Metanorma::Document::Components::BibData::BibliographicItem
       attribute :entry, Entry, collection: true
 
       xml do

data/lib/metanorma/{collection → document_collection}/root.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Metanorma
-  module Collection
+  module DocumentCollection
     # Root model for <metanorma-collection> XML.
     # Represents a collection of Metanorma documents bundled together,
     # with shared metadata, directives, and a manifest of entries.
@@ -10,7 +10,7 @@ module Metanorma
     # (presentation). Embedded <metanorma> documents inside doc-containers use
     # the standoc namespace (https://www.metanorma.org/ns/standoc).
     class Root < Lutaml::Model::Serializable
-      attribute :bibdata, Metanorma::IsoDocument::Metadata::IsoBibliographicItem
+      attribute :bibdata, Metanorma::Document::Components::BibData::BibliographicItem
       attribute :directive, Directive, collection: true
       attribute :entry, Entry
       attribute :format, :string, collection: true