metanorma-standoc 3.5.0 → 3.5.1.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95fe16d69ea9558d1d2b3cec445ae0d71cfeb90f319ba138e631a05034421b1c
-  data.tar.gz: eafe128e6beaf35465a309a24b043ceb23ba84c330e4ba40930bd90b6952aebb
+  metadata.gz: 8001a19a529d536d37e1f035e1fcc45585ecfdecaece0e2466b00a684807f71c
+  data.tar.gz: aa1838be7a5e6dfb6675251a4c0871aafb58e427a4bea598a60849e5263b4e22
 SHA512:
-  metadata.gz: ce581d496eba88c15d71bdc63f55206c14bc4f823f5fcaabb9cbbfb982c6b32a555472c67e1ef9ca08fb1d3ca6cb3d67a33c5f93a4ea14777af4038814a45ef1
-  data.tar.gz: 817f107bdbf9d2e2ddf2f3ba8c6dd7e1f520b5945e61dc93d97fbad0c1fca1342332cdb4453ee5b52f4ad4fbee3e17209248d4716db20e6205b36f7eb3838b39
+  metadata.gz: 48756dd12f0f9ba7f553e0c762b398688d812bf86780a6a860f88c09c32395e7460a3bbc9556e0a0c02b5d9d61a998ff1897c04708b6f545693e6600ceb93be8
+  data.tar.gz: c9bfc8a020ab69a476d91d737acdf13d319b41b8e234b64d23ceb2770ab976cf79dbddd984c3393a395bae69adc54cd2d06797e4b725c023ac1c5bfb4ce5ef78

data/Gemfile

@@ -5,6 +5,7 @@ source "https://rubygems.org"
 git_source(:github) { |repo| "https://github.com/#{repo}" }
 
 gemspec
+gem "metanorma-mirror", "~> 1.0", github: "metanorma/metanorma-mirror", branch: "main"
 
 # Stopgap: lutaml 0.11.x removed lib/lutaml/xmi.rb, which metanorma-plugin-lutaml
 # 0.7.x still `require`s. Hold lutaml at 0.10.x until plugin-lutaml follows the
@@ -12,4 +13,26 @@ gemspec
 # https://github.com/metanorma/metanorma-plugin-lutaml/issues/292
 gem "lutaml", "< 0.11"
 
+# TEMPORARY: cross-PR branch pins so CI can resolve the in-flight pubid-2 /
+# relaton-bib 2.2 / metanorma-document 0.5 chain. Revert each to its
+# released line once the corresponding PR merges.
+# TEMPORARY pin: the svgmap/imagemap models (metanorma-document#62/#63
+# branch) — flip to main when they merge.
+gem "metanorma-document", github: "metanorma/metanorma-document",
+    branch: "main"
+# document seed registers — restore main on merge, version on release.
+# isodoc: relaton-cli 3.0.0.pre allowance (#824) merged after the 3.7.2 release — main until the next release
+gem "isodoc", github: "metanorma/isodoc", branch: "main"
+# relaton 3.0.0.pre.alpha.1 from rubygems called the removed pubid
+# base_identifier; the fix (db9840bdf) shipped in the 3.0.0.pre.alpha.4
+# release. Prefer the released gem over a git pin: relaton main has since
+# moved to lutaml-store ~> 0.3, which conflicts with glossarist 2.14's
+# lutaml-store ~> 0.2.0 and makes this bundle unresolvable.
+gem "relaton", "~> 3.0.0.pre.alpha" # the 3.0.0.pre line: alpha.17 carries singular_tolerance + the worker-pool fix
+gem "pubid", "~> 2.0.0.pre.alpha"
+
+gem "metanorma-plugin-lutaml", github: "metanorma/metanorma-plugin-lutaml", branch: "main"
+
 eval_gemfile("Gemfile.devel") rescue nil
+
+gem "metanorma-utils", "~> 2.0.8" # GcBudget (utils#54) + the array-join asciidoctor table cell buffer (utils#55/#56), released in 2.0.8, github: "metanorma/metanorma-utils", branch: "main"

data/lib/metanorma/cleanup/bibdata.rb

@@ -192,7 +192,11 @@ module Metanorma
         ins = add_misc_container(xmldoc)
         ins ||= add_misc_container(xmldoc)
         ins.at("./semantic-metadata/stage-published") and return
-        p = published_base?(xmldoc.at("bibdata/status/stage")&.text, xmldoc)
+        # Absolute path: the sectioned assembly nests bibdata one level
+        # deeper than the classic document, so a root-relative lookup
+        # misses the stage and stage-published resolves "false"
+        # (metanorma-standoc#1290). The absolute form finds both shapes.
+        p = published_base?(xmldoc.at("//bibdata/status/stage")&.text, xmldoc)
         ins << <<~XML
           <semantic-metadata><stage-published>#{p}</stage-published></semantic-metadata>
         XML

data/lib/metanorma/cleanup/bibitem.rb

@@ -28,11 +28,17 @@ module Metanorma
         merge_bibitem_from_formattedref_span_attrs(bib, new)
         if bib.at("./title") && bib["amend"]
           # there already is a fetched record here: merge
-          bib.children = Metanorma::Standoc::Cleanup::MergeBibitems
-            .new(bib.to_xml, new.to_xml).merge.to_noko.children
+          # to_noko children are Nokogiri natives; handing them to moxml's
+          # children= crosses adapters (type-confused natives under leptris,
+          # segfault at serialize on windows). Serialize to markup and let
+          # moxml re-parse in bib's own context.
+          merged = Metanorma::Standoc::Cleanup::MergeBibitems
+            .new(bib.to_xml, new.to_xml).merge.to_noko.children.to_xml
+          bib.children = merged
         elsif bib.at("./title") # replace record
-          bib.children = new.children.to_xml
-        else bib << new.children.to_xml
+          bib.children = new.children.map(&:to_xml).join
+        else
+          bib << new.children.map(&:to_xml).join
         end
         bibitem_reorder_elems(bib)
       end

data/lib/metanorma/cleanup/boilerplate.rb

@@ -41,7 +41,11 @@ module Metanorma
 
       def dup_with_namespace(elem)
         ret = elem.dup
-        ret.add_namespace(nil, @conv.xml_namespace)
+        # adding a namespace to a deep-copied leptris tree corrupts it
+        # (segfault at serialize); flavors without an XML namespace
+        # never needed the call
+        ns = @conv.xml_namespace
+        ret.add_namespace(nil, ns) if ns
         ret
       end
 

data/lib/metanorma/cleanup/image.rb

@@ -7,7 +7,27 @@ module Metanorma
       def svgmap_cleanup(xmldoc)
         svgmap_moveattrs(xmldoc)
         svgmap_populate(xmldoc)
-        Vectory::SvgMapping.new(xmldoc, @localdir).call
+        processed = Vectory::SvgMapping.new(xmldoc, @localdir).call.to_xml
+
+        # vectory 0.13 processes on its own tree and returns the result
+        # instead of mutating the caller's document; reparse the processed
+        # XML with the caller's own XML library and graft the content back
+        # so the cleanup pipeline (which threads xmldoc by reference
+        # through every step) keeps working. With vectory 0.12 the document
+        # is already mutated and the graft is a no-op.
+        new_doc = if defined?(Moxml) && xmldoc.is_a?(Moxml::Node)
+                    Moxml.new.parse(processed)
+                  elsif defined?(Nokogiri) && xmldoc.is_a?(Nokogiri::XML::Node)
+                    Nokogiri::XML(processed)
+                  else
+                    raise ArgumentError,
+                          "unsupported xmldoc type: #{xmldoc.class}"
+                  end
+        old_root = xmldoc.root
+        new_root = new_doc.root
+        old_root.children.each(&:remove)
+        new_root.children.each { |n| old_root << n }
+        xmldoc
       end
 
       def svgmap_moveattrs(xmldoc)

data/lib/metanorma/cleanup/inline.rb

@@ -161,8 +161,29 @@ module Metanorma
       # overwrite xmldoc, so must assign result to xmldoc
       def passthrough_metanorma_cleanup(doc)
         ret = to_xml(doc)
-          .gsub(%r{<passthrough formats="metanorma">([^<]*)</passthrough>}) { @c.decode($1) }
-        doc.root = Nokogiri::XML(ret, &:huge).root
+          .gsub(%r{<passthrough formats="metanorma">([^<]*)</passthrough>}) do
+            encoded = $1
+            content = @c.decode(encoded)
+            passthrough_injectable?(content) ? content : encoded
+          end
+        doc.root = if doc.is_a?(Moxml::Document)
+                     @conv.moxml_context.parse(ret).root
+                   else
+                     Nokogiri::XML(ret, &:huge).root
+                   end
+      end
+
+      # Passthrough content is markup to splice into the document. Text
+      # that is malformed XML (an escaped literal such as
+      # "&lt;Date Approved&gt;", or a bare "&") must stay escaped:
+      # decoding it would corrupt the reparse. Tag-name mismatch alone
+      # is not disqualifying: markup legitimately split across
+      # consecutive passthroughs reports it until the pieces meet.
+      TAG_MISMATCH = 76 # XML_ERR_TAG_NAME_MISMATCH
+
+      def passthrough_injectable?(content)
+        Nokogiri::XML::DocumentFragment.parse(content).errors
+          .all? { |e| e.code == TAG_MISMATCH }
       end
 
       def link_cleanup(xmldoc)

data/lib/metanorma/cleanup/maths.rb

@@ -72,11 +72,19 @@ module Metanorma
       end
 
       def xml_unescape_mathml(xml)
-        xml.children.any?(&:element?) and return
-        math = xml.text.gsub("&lt;", "<").gsub("&gt;", ">")
-          .gsub("&quot;", '"').gsub("&apos;", "'").gsub("&amp;", "&")
-          .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
-        xml.children = math
+        if xml.children.any?(&:element?)
+          # The stem macro hands the builder raw markup, so a MathML
+          # fragment whose flavor prefix is unbound at the root parses
+          # into bare "mml:"-named elements; namespace-aware cleanup
+          # cannot see them. Re-normalize over the serialized tree.
+          xml.children = xml.children.to_xml
+            .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
+            .gsub(/\s+xmlns:[^=]+="[^"]*"/, "")
+        else
+          xml.children = xml.text.gsub("&lt;", "<").gsub("&gt;", ">")
+            .gsub("&quot;", '"').gsub("&apos;", "'").gsub("&amp;", "&")
+            .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
+        end
       end
 
       def mathml_preserve_space(math)
@@ -88,19 +96,30 @@ module Metanorma
 
       def mathml_namespace(stem)
         stem.xpath("./*[local-name() = 'math']").each do |x|
-          x.default_namespace = MATHML_NS
+          if (prefix = x.name[/\A([^:]+):/, 1])
+            # a stem may arrive with a prefixed MathML root (mml:math);
+            # a default namespace does not bind that prefix, so the
+            # serialized document is not well-formed. Bind the prefix.
+            x.add_namespace_definition(prefix, MATHML_NS)
+          else
+            x.default_namespace = MATHML_NS
+          end
         end
       end
 
       UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
 
       def add_misc_container(xmldoc)
-        unless ins = xmldoc.at("//metanorma-extension")
-          a = xmldoc.xpath("//termdocsource")&.last || xmldoc.at("//bibdata") ||
-            xmldoc.root.children.first
-          a.next = "<metanorma-extension/>"
-          ins = xmldoc.at("//metanorma-extension")
-        end
+        ins = xmldoc.at("//metanorma-extension")
+        return ins if ins
+
+        a = xmldoc.xpath("//termdocsource")&.last || xmldoc.at("//bibdata") ||
+          xmldoc.root.children.first
+        # Create in the document's pool and return the node: a
+        # fragment-parsed node belongs to another Moxml document, and
+        # re-querying it back can miss on the native Leptris lane.
+        ins = xmldoc.create_element("metanorma-extension")
+        a.next = ins
         ins
       end
 

data/lib/metanorma/cleanup/section.rb

@@ -39,7 +39,14 @@ module Metanorma
           preface = sect.at("//preface") ||
             sect.add_previous_sibling("<preface/>").first
           abstract = xml.at("//abstract[not(ancestor::bibitem)]").remove
-          preface.prepend_child abstract.remove
+          # prepend_child is a Nokogiri-only API; the first-child
+          # previous-sibling insertion works on every adapter
+          first = preface.children.first
+          if first
+            first.add_previous_sibling(abstract.remove)
+          else
+            preface.add_child(abstract.remove)
+          end
           bibabstract = bibabstract_location(xml)
           bibabstract.next = clean_abstract(abstract.dup)
         end
@@ -47,6 +54,8 @@ module Metanorma
 
       def clean_abstract(dupabstract)
         dupabstract.traverse do |n|
+          next unless n.element? # only elements carry attributes
+
           n.remove_attribute("id")
           n.remove_attribute("anchor")
         end
@@ -70,7 +79,19 @@ module Metanorma
 
       def make_bibliography(xml, sect)
         if xml.at("//sections/references | //xref[@hidden]")
-          biblio = sect.add_next_sibling("<bibliography/>").first
+          # On the FFI-only Moxml lane (no compiled Leptris read layer,
+          # e.g. Ruby 4.0), a fragment-parsed wrapper belongs to another
+          # document and cross-pool appends drop silently. Create it in
+          # the document's own pool there; the native lane handles the
+          # fragment path and rejects document-created inserts when
+          # combined with later pool operations.
+          biblio = if xml.is_a?(Moxml::Document) && !defined?(::Leptris::XML::NativeNode)
+                     xml.create_element("bibliography").tap do |b|
+                       sect.add_next_sibling(b)
+                     end
+                   else
+                     sect.add_next_sibling("<bibliography/>").first
+                   end
           xml.xpath("//sections/references").each do |r|
             biblio.add_child r.remove
           end

data/lib/metanorma/cleanup/spans_to_bibitem_preprocessing.rb

@@ -19,7 +19,10 @@ module Metanorma
           acc << { key: keys[0], type: keys[1],
                    val: span.children.to_xml }
           (span["class"] == "type" and span.remove) or
-            span.replace(span.children)
+            # moxml's replace accepts a fragment string and preserves text
+            # nodes; its add_previous_sibling drops text children, and node
+            # moves over a live collection lose the leading ones
+            span.replace(span.children.to_xml)
         end
 
         def extract_docid(bib)

data/lib/metanorma/cleanup/terms.rb

@@ -33,7 +33,11 @@ module Metanorma
       def generate_termdefinitions(xmldoc)
         xmldoc.xpath("//term[not(definition)]").each do |d|
           first_child = d.at(TERMDEF_BLOCKS) || next
-          t = Nokogiri::XML::Element.new("definition", xmldoc)
+          t = if xmldoc.respond_to?(:create_element)
+                xmldoc.create_element("definition")
+              else
+                Nokogiri::XML::Element.new("definition", xmldoc)
+              end
           add_id(t)
           first_child.replace(t)
           t << first_child.remove

data/lib/metanorma/cleanup/text.rb

@@ -80,7 +80,9 @@ module Metanorma
 
       # "abc<tag/>", def => "abc",<tag/> def
       def uninterrupt_quotes_around_xml(xmldoc)
+        i = 0
         xmldoc.traverse do |n|
+          Metanorma::Utils::GcBudget.gc_when_bloated! if ((i += 1) % 1000).zero?
           next unless n.text? && n&.previous&.element?
           next if uninterrupt_quotes_around_xml_skip(n)
 
@@ -145,7 +147,9 @@ module Metanorma
 
       def dumb2smart_quotes(xmldoc)
         prev = ""
+        n = 0
         xmldoc.traverse do |x|
+          Metanorma::Utils::GcBudget.gc_when_bloated! if ((n += 1) % 1000).zero?
           block?(x) and prev = ""
           empty_tag_with_text_content?(x) and prev = "dummy"
           x.text? or next
@@ -164,11 +168,13 @@ module Metanorma
       end
 
       def dumbquote_cleanup(xmldoc)
-        xmldoc.traverse do |n|
-          next unless n.text? && n.text.include?("\u2019")
+        i = 0
+        xmldoc.traverse do |node|
+          Metanorma::Utils::GcBudget.gc_when_bloated! if ((i += 1) % 1000).zero?
+          next unless node.text? && node.text.include?("\u2019")
 
-          n.replace(@c.encode(
-                      @c.decode(n.text)
+          node.replace(@c.encode(
+                         @c.decode(node.text)
             .gsub(/(?<=\p{Alnum})\u2019(?=\p{Alpha})/, "'"),
                       :basic, :hexadecimal
                     ))

data/lib/metanorma/converter/base.rb

@@ -1,5 +1,6 @@
 require "date"
 require "nokogiri"
+require "moxml"
 require "htmlentities"
 require "pathname"
 require "isodoc"
@@ -49,17 +50,27 @@ module Metanorma
         ret
       end
 
-      def insert_xml_cr(doc)
-        doc.gsub(%r{(</(clause|table|figure|p|bibitem|ul|ol|dl|dt|dd|li|example|
+      # In-place bang passes: the three sequential whole-document
+      # substitutions each allocate a full copy of the document string
+      # when written with non-bang gsub; on large compiles this phase
+      # was a top transient-allocation site. Sequential semantics are
+      # preserved exactly (the sourcecode/name collapse relies on the
+      # newlines the first two passes insert).
+      CLOSE_TAG = %r{(</(clause|table|figure|p|bibitem|ul|ol|dl|dt|dd|li|example|
             sourcecode|formula|quote|references|annex|appendix|title|name|note|
             thead|tbody|tfoot|th|td|form|requirement|recommendation|permission|
             imagemap|svgmap|preferred|admitted|related|domain|deprecates|
             letter-symbol|graphical-symbol|expression|subject|abbreviation-type|
             pronunciation|grammar|term|terms|termnote|termexample|source|
-            origin|termref|modification)>)}x, "\\1\n")
-          .gsub(%r{(<(title|name))}, "\n\\1")
-          .gsub(%r{(<sourcecode[^<>]*+>)\s++(<name[^<>]*+>(?>.*?</name>))\s++}m,
-                "\\1\\2")
+            origin|termref|modification)>)}x.freeze
+      OPEN_TITLE_NAME = %r{(<(title|name))}.freeze
+      SOURCECODE_NAME = %r{(<sourcecode[^<>]*+>)\s++(<name[^<>]*+>(?>.*?</name>))\s++}m.freeze
+
+      def insert_xml_cr(doc)
+        doc.gsub!(CLOSE_TAG, "\\1\n")
+        doc.gsub!(OPEN_TITLE_NAME, "\n\\1")
+        doc.gsub!(SOURCECODE_NAME, "\\1\\2")
+        doc
       end
 
       def version
@@ -69,7 +80,7 @@ module Metanorma
 
       def schema_version
         f = File.read(File.join(File.dirname(__FILE__), "..", "validate",
-                                "isodoc.rng"))
+                                "standoc.rng"))
         m = / VERSION (v\S+)/.match(f)
         m[1]
       end
@@ -95,17 +106,34 @@ module Metanorma
           <#{xml_root_tag} type='semantic' version='#{version}' schema-version='#{schema_version}' flavor='#{processor.new.asciidoctor_backend}'>
         XML
                   noko { |ixml| front node, ixml },
-                  noko { |ixml| middle node, ixml },
+                  semantic_body(node),
                   "</#{xml_root_tag}>"]
-        insert_xml_cr(textcleanup(result))
+        Metanorma::Utils::GcBudget.gc_when_bloated!
+        insert_xml_cr(textcleanup(result)).tap do
+          # The assembly passes build three whole-document string
+          # copies; collect before the cleanup parse so the budget
+          # reflects post-assembly, not mid-string, pressure.
+          Metanorma::Utils::GcBudget.gc_when_bloated!
+        end
+      end
+
+      def semantic_body(node)
+        if sectioned_semantic?(node)
+          @sectioned_semantic = true
+          middle_sectioned(node)
+        else
+          noko { |ixml| middle node, ixml }
+        end
       end
 
       def makexml(node)
         result = makexml1(node)
         ret1 = cleanup(result)
+        Metanorma::Utils::GcBudget.gc_when_bloated!
         unless @novalid || in_isolated_conversion?
           validate_processor = validate_class.new(self)
           validate_processor.validate(ret1)
+          Metanorma::Utils::GcBudget.gc_when_bloated!
           @files_to_delete = validate_processor.files_to_delete
         end
         ret1
@@ -117,8 +145,16 @@ module Metanorma
         )
       end
 
+      def moxml_context
+        @moxml_context ||= Moxml.new(:leptris)
+      end
+
       def cleanup(result)
-        ret1 = Nokogiri::XML(result)
+        ret1 = if @sectioned_semantic
+                 moxml_context.parse(result)
+               else
+                 Nokogiri::XML(result)
+               end
         @nocleanup and return ret1
         cleanup_processor = cleanup_class.new(self)
         ret1 = cleanup_processor.cleanup(ret1)
@@ -161,6 +197,26 @@ module Metanorma
         end
       end
 
+      # `:sectioned-semantic:` assembles <sections> through the leptris
+      # engine (moxml) instead of the classic whole-document Nokogiri
+      # fragment; falls back when middle() is overridden by a flavor
+      def sectioned_semantic?(node)
+        !node.attr("sectioned-semantic").nil? &&
+          method(:middle).owner == Metanorma::Standoc::Base
+      end
+
+      # node.content is already fully serialized per section; a single
+      # parse into a lean leptris DOM replaces the classic
+      # parse+serialize round trip. The doc wrapper is held while
+      # serializing: it owns the native tree via a GC finalizer.
+      def middle_sectioned(node)
+        return "<sections/>" unless node.blocks?
+
+        context = Moxml.new(:leptris)
+        doc = context.parse("<sections>#{node.content}</sections>")
+        doc.root.to_xml(indent: 0)
+      end
+
       def metadata_attrs(node)
         out = node.attributes.each_with_object([]) do |(k, v), ret|
           %w(presentation semantic).each do |t|

data/lib/metanorma/converter/converter.rb

@@ -23,9 +23,14 @@ module Metanorma
     class Converter
       Asciidoctor::Extensions.register do
         preprocessor Metanorma::Standoc::ResolveIncludePreprocessor
+        treeprocessor Metanorma::Plugin::Asciichem::Extension::ChemTreeprocessor
+        inline_macro Metanorma::Plugin::Asciichem::Extension::ChemInlineMacro, :chem
+        preprocessor Metanorma::Plugin::Lutaml::LutamlDataPreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlXsdPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlEaXmiPreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::XmiPartialLoadPreprocessor
         inline_macro Metanorma::Plugin::Lutaml::LutamlFigureInlineMacro
         inline_macro Metanorma::Plugin::Lutaml::LutamlTableInlineMacro
         block_macro Metanorma::Plugin::Lutaml::LutamlDiagramBlockMacro

data/lib/metanorma/converter/front.rb

@@ -164,13 +164,39 @@ module Metanorma
         id = doc.split(/,\s*/)
         xml.relation type: relation_normalise(type) do |r|
           desc.nil? or r.description desc.tr("-", " ")
-          fetch_ref(r, doc, nil, **{}) or r.bibitem do |b|
+          relation_fetch_ref(r, doc) or r.bibitem do |b|
             add_noko_elem(b, "title", id[1] || "--")
             add_noko_elem(b, "docidentifier", id[0])
           end
         end
       end
 
+      # A relation described in document attributes is free text, not a
+      # normative citation: an unrecognized identifier logs and falls back to
+      # the plain bibitem instead of aborting metadata processing.
+      #
+      # The errors an unresolvable relation reference raises depend on the
+      # relaton/pubid generation in the bundle: newer relaton raises
+      # Relaton::UnknownReferenceError on strict routing (relaton#243),
+      # older ones surface the same condition as Pubid::Errors::ParseError
+      # when the free text is not a parseable identifier. Resolving the
+      # error set dynamically also keeps the rescue clause itself from
+      # raising NameError on bundles where a class is absent — which
+      # masked the real error and aborted the conversion.
+      def relation_fetch_ref(relation, doc)
+        fetch_ref(relation, doc, nil, **{})
+      rescue *unresolved_reference_errors
+        @log.add("STANDOC_40", nil, params: [doc])
+        nil
+      end
+
+      def unresolved_reference_errors
+        [
+          (Relaton::UnknownReferenceError if defined?(Relaton::UnknownReferenceError)),
+          (Pubid::Errors::ParseError if defined?(Pubid::Errors::ParseError)),
+        ].compact
+      end
+
       def metadata_keywords(node, xml)
         node.attr("keywords") or return
         node.attr("keywords").split(/,\s*/).each do |kw|

data/lib/metanorma/converter/macros.rb

@@ -9,6 +9,7 @@ require_relative "macros_embed"
 require_relative "macros_link"
 require_relative "macros_nosub"
 require_relative "macros_number"
+require "metanorma-plugin-asciichem"
 require "metanorma-plugin-glossarist"
 require "metanorma-plugin-lutaml"
 require "metanorma-plugin-plantuml"

data/lib/metanorma/converter/macros_nosub.rb

@@ -17,18 +17,28 @@ module Metanorma
       PASS_INLINE_MACROS = %w(pass pass-format identifier std-link stem)
         .join("|").freeze
 
+      # NOTE: the pattern deliberately carries no /x-mode comments —
+      # TruffleRuby's TRegex parser rejects this pattern whenever any /x
+      # comment is present ("missing ), unterminated subpattern",
+      # https://github.com/truffleruby/truffleruby/issues/4435). /x strips
+      # comments and layout whitespace before parsing, so this spelling
+      # compiles to the identical regex on every engine. Anatomy, for the
+      # reader:
+      #   \b(?<![-\\])                      word separator, no hyphen/backslash
+      #   (?:(?:MACROS):[^\s\[]* | span: [^\s\[]*)
+      #       macro name + second key, OR any span: macro (e.g. span:uri,
+      #       span:note.display): protect its bracketed content from
+      #       URL/link rewriting so an injected link:[] cannot close the
+      #       span early
+      #   \[.*?(?<!\\)\]                    [...] not preceded by backslash
       PASS_INLINE_MACRO_STR = <<~REGEX.freeze
         (
-          \\b(?<![-\\\\])                        # word-separator, no hyphen or backslash
-          (?:                                    # don't capture these!
-            (?:#{PASS_INLINE_MACROS}):[^\\s\\[]* | # macro name, :, second key. OR:
-            span: [^\\s\\[]*                     # any span: macro (e.g. span:uri,
-                                                # span:note.display): protect its
-                                                # bracketed content from URL/link
-                                                # rewriting so an injected link:[]
-                                                # can't close the span early
+          \\b(?<![-\\\\])
+          (?:
+            (?:#{PASS_INLINE_MACROS}):[^\\s\\[]* |
+            span: [^\\s\\[]*
           )
-          \\[.*?(?<!\\\\)\\]                     # [ ... ] not preceded by \\
+          \\[.*?(?<!\\\\)\\]
         )
       REGEX
       PASS_INLINE_MACRO_RX = /#{PASS_INLINE_MACRO_STR}/xo
@@ -128,18 +138,28 @@ module Metanorma
       PASS_INLINE_MACROS = %w(pass pass-format identifier std-link stem)
         .join("|").freeze
 
+      # NOTE: the pattern deliberately carries no /x-mode comments —
+      # TruffleRuby's TRegex parser rejects this pattern whenever any /x
+      # comment is present ("missing ), unterminated subpattern",
+      # https://github.com/truffleruby/truffleruby/issues/4435). /x strips
+      # comments and layout whitespace before parsing, so this spelling
+      # compiles to the identical regex on every engine. Anatomy, for the
+      # reader:
+      #   \b(?<![-\\])                      word separator, no hyphen/backslash
+      #   (?:(?:MACROS):[^\s\[]* | span: [^\s\[]*)
+      #       macro name + second key, OR any span: macro (e.g. span:uri,
+      #       span:note.display): protect its bracketed content from
+      #       URL/link rewriting so an injected link:[] cannot close the
+      #       span early
+      #   \[.*?(?<!\\)\]                    [...] not preceded by backslash
       PASS_INLINE_MACRO_STR = <<~REGEX.freeze
         (
-          \\b(?<![-\\\\])                        # word-separator, no hyphen or backslash
-          (?:                                    # don't capture these!
-            (?:#{PASS_INLINE_MACROS}):[^\\s\\[]* | # macro name, :, second key. OR:
-            span: [^\\s\\[]*                     # any span: macro (e.g. span:uri,
-                                                # span:note.display): protect its
-                                                # bracketed content from URL/link
-                                                # rewriting so an injected link:[]
-                                                # can't close the span early
+          \\b(?<![-\\\\])
+          (?:
+            (?:#{PASS_INLINE_MACROS}):[^\\s\\[]* |
+            span: [^\\s\\[]*
           )
-          \\[.*?(?<!\\\\)\\]                     # [ ... ] not preceded by \\
+          \\[.*?(?<!\\\\)\\]
         )
       REGEX
       PASS_INLINE_MACRO_RX = /#{PASS_INLINE_MACRO_STR}/xo

data/lib/metanorma/converter/utils.rb

@@ -84,8 +84,14 @@ module Metanorma
       end
 
       def to_xml(node)
-        node.to_xml(encoding: "UTF-8", indent: 2,
-                    save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+        if defined?(Moxml::Document) && node.is_a?(Moxml::Document)
+          # expand_empty: false — self-close empty elements, matching
+          # the Nokogiri AS_XML output the classic pipeline emits
+          node.to_xml(encoding: "UTF-8", indent: 2, expand_empty: false)
+        else
+          node.to_xml(encoding: "UTF-8", indent: 2,
+                      save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+        end
       end
 
       SUBCLAUSE_XPATH = "//clause[not(parent::sections)]" \