moxml 0.5.149 → 0.5.151

data/spec/consistency/model_coverage_audit_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "support/model_coverage"
 
 # Model coverage matrix (TODO.model/03): every face family of the
 # processing model is governed for every adapter — covered by a pin
@@ -8,84 +9,13 @@ require "spec_helper"
 # a registered divergence (adapter => D-ID), or loud (adapter =>
 # the named error class). An unpinned family is an ungoverned cell:
 # this audit fails until it has one of the three.
-# See docs/_references/processing-model.adoc for the model itself.
+#
+# The matrix itself lives in spec/support/model_coverage.rb: the same
+# data drives this audit, the model document's pin lists, and the
+# published coverage page. See docs/_references/processing-model.adoc
+# for the model itself.
 RSpec.describe "model coverage matrix" do
-  MODEL_MATRIX = { # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-    "document order and children listing" => {
-      section: "Document order and traversal",
-      pin: "spec/consistency/adapter_parity_spec.rb",
-    },
-    "name resolution" => {
-      section: "Names and namespaces",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-    },
-    "namespace resolution and bindings normalization" => {
-      section: "Names and namespaces",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-    },
-    "attribute access" => {
-      section: "Access semantics",
-      pin: "spec/moxml/attribute_resolver_spec.rb",
-    },
-    "text/content/raw_content" => {
-      section: "Access semantics",
-      pin: "spec/moxml/text_spec.rb",
-    },
-    "parsing modes and diagnostics" => {
-      section: "Parsing",
-      pin: "spec/moxml/document_parse_diagnostics_spec.rb",
-    },
-    "EOL normalization" => {
-      section: "Parsing",
-      pin: "spec/consistency/eol_normalization_spec.rb",
-      exempt: { oga: "D-02", ox: "D-03" },
-    },
-    "entity modes" => {
-      section: "Parsing",
-      pin: "spec/moxml/entity_spec.rb",
-    },
-    "XPath evaluation and declared idioms" => {
-      section: "XPath evaluation",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-      exempt: { oga: "D-01" },
-    },
-    "serialization shapes (xml/html/xhtml)" => {
-      section: "Serialization",
-      pin: "spec/moxml/xhtml_output_spec.rb",
-    },
-    "indentation knobs" => {
-      section: "Serialization",
-      pin: "spec/moxml/to_html_spec.rb",
-      exempt: { oga: "D-09", ox: "D-09", headed_ox: "D-09",
-                libxml: "D-09", leptris: "D-09" },
-    },
-    "canonicalization" => {
-      section: "Canonicalization",
-      pin: "spec/moxml/c14n/adapter_delegation_spec.rb",
-      exempt: { oga: "D-04", ox: "D-05", headed_ox: "D-05" },
-    },
-    "XSLT" => {
-      section: "XSLT",
-      pin: "spec/consistency/xslt_spec.rb",
-      loud: { oga: "Moxml::NotImplementedError",
-              ox: "Moxml::NotImplementedError",
-              headed_ox: "Moxml::NotImplementedError",
-              rexml: "Moxml::NotImplementedError",
-              libxml: "Moxml::NotImplementedError" },
-    },
-    "SAX" => {
-      section: "SAX",
-      pin: "spec/moxml/sax_spec.rb",
-    },
-    "materialization" => {
-      section: "Materialization",
-      pin: "spec/moxml/plan_conformance_spec.rb",
-    },
-    "loud capability contracts" => {
-      section: "Errors and loud degradation",
-      pin: "spec/consistency/loud_degradation_spec.rb",
-    },
-  }.freeze
+  MODEL_MATRIX = ModelCoverage::MODEL_COVERAGE_MATRIX # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
   def register_ids
     File.readlines("docs/_pages/divergences.adoc")
@@ -134,12 +64,7 @@ RSpec.describe "model coverage matrix" do
   # section vanished fails too.
   MODEL_DOC = "docs/_references/processing-model.adoc" # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
-  NON_FACE_SECTIONS = [ # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-    "Status and precedence",
-    "Mission and invariant",
-    "Object model",
-    "Performance: a declared, non-semantic channel",
-  ].freeze
+  NON_FACE = ModelCoverage::MODEL_COVERAGE_NON_FACE # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
   def model_sections
     File.readlines(MODEL_DOC).filter_map do |line|
@@ -147,6 +72,24 @@ RSpec.describe "model coverage matrix" do
     end.uniq
   end
 
+  # Document-side pin lists (TODO.sota/07): every section carries a
+  # `Pins::` line naming the specs that enforce it (`Pins:: none` for
+  # non-face sections). Parsed as section => [paths] or nil when the
+  # line is missing.
+  def model_pin_lists
+    lists = {}
+    current = nil
+    File.readlines(MODEL_DOC).each do |line|
+      if (heading = line[/\A=== (\S.*)$/, 1])
+        current = heading.strip
+        lists[current] = nil
+      elsif current && (entry = line[/\APins:: (.*)$/, 1])
+        lists[current] = entry.scan(/`([^`]+)`/).flatten
+      end
+    end
+    lists
+  end
+
   it "cites an existing model section for every face family" do
     sections = model_sections
     unknown = MODEL_MATRIX.filter_map do |family, cell|
@@ -162,7 +105,7 @@ RSpec.describe "model coverage matrix" do
   it "covers or declares every model section" do
     cited = MODEL_MATRIX.values.filter_map { |cell| cell[:section] }
     uncovered = model_sections.reject do |section|
-      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+      cited.include?(section) || NON_FACE.include?(section)
     end
     expect(uncovered).to be_empty,
                          "model sections with no coverage matrix family " \
@@ -170,11 +113,43 @@ RSpec.describe "model coverage matrix" do
   end
 
   it "declares non-face sections that actually exist in the model doc" do
-    stale = NON_FACE_SECTIONS.reject { |s| model_sections.include?(s) }
+    stale = NON_FACE.reject { |s| model_sections.include?(s) }
     expect(stale).to be_empty,
                      "non-face declarations citing missing sections: #{stale.join('; ')}"
   end
 
+  it "gives every model section a Pins line" do
+    missing = model_pin_lists.select { |_, pins| pins.nil? }.keys
+    expect(missing).to be_empty,
+                       "model sections without a Pins line: #{missing.join('; ')}"
+  end
+
+  it "matches the model doc's face-section pin lists to the matrix" do
+    lists = model_pin_lists
+    drift = ModelCoverage.sections.filter_map do |section|
+      expected = ModelCoverage.pins_for(section)
+      got = lists[section]
+      "#{section}: doc #{got.inspect} vs matrix #{expected.inspect}" if got != expected
+    end
+    expect(drift).to be_empty,
+                     "model-doc pin lists drift from the matrix: #{drift.join('; ')}"
+  end
+
+  it "leaves non-face sections without pins" do
+    lists = model_pin_lists
+    pinned = NON_FACE.select { |section| lists[section]&.any? }
+    expect(pinned).to be_empty,
+                      "non-face sections must declare Pins:: none: #{pinned.join('; ')}"
+  end
+
+  it "points every model-doc pin at an existing spec" do
+    missing = model_pin_lists.values.compact.flatten.uniq.reject do |path|
+      File.exist?(path)
+    end
+    expect(missing).to be_empty,
+                       "model-doc pins missing on disk: #{missing.join(', ')}"
+  end
+
   # Bidirectional linkage (TODO.sota/03): the model doc, the pins, and
   # the reference form one checkable triangle. Every pin cites the
   # section it enforces; every citation names a section that exists.
@@ -213,7 +188,7 @@ RSpec.describe "model coverage matrix" do
       File.exist?(path) ? pin_citations(path) : []
     end
     uncovered = model_sections.reject do |section|
-      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+      cited.include?(section) || NON_FACE.include?(section)
     end
     expect(uncovered).to be_empty,
                          "model sections no pin cites: #{uncovered.join('; ')}"

data/spec/consistency/published_docs_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/model_coverage"
+require "json"
+
+# Published documentation is part of the specification apparatus
+# (TODO.sota/07): generated blocks must be views of committed data. A
+# data change without regeneration fails here, so the published
+# coverage proof and scoreboard can never claim more than the tests do.
+RSpec.describe "published documentation" do
+  it "keeps the model-coverage page in sync with the matrix" do
+    page = File.read("docs/_pages/model-coverage.adoc")
+    block = page[/MODEL-COVERAGE:BEGIN\n(.*?)\n?\/\/ MODEL-COVERAGE:END/m, 1]
+    expect(block).not_to be_nil, "coverage page is missing its markers"
+
+    expect(block).to eq(ModelCoverage.render_page_block),
+                     "model-coverage page is stale: run rake docs:coverage"
+  end
+
+  it "keeps every published scoreboard row in sync with the JSON data" do
+    data = JSON.parse(File.read("benchmark/scoreboard.json"))
+    page = File.read("docs/_pages/performance.adoc")
+    block = page[/SCOREBOARD:BEGIN(.*?)SCOREBOARD:END/m, 1]
+    expect(block).not_to be_nil, "performance page is missing its markers"
+
+    data["rows"].each do |row|
+      expect(block).to include(
+        "| `#{row['row']}` | #{format('%.2f', row['ratio'])}x | " \
+        "#{row['kind']} |",
+      ), "scoreboard row #{row['row']} is stale against scoreboard.json"
+    end
+
+    expect(block.scan(/\| `[^`]+` \| \d+\.\d\dx \|/).size)
+      .to eq(data["rows"].size), "scoreboard row count differs"
+  end
+
+  it "names the measured engine version in the scoreboard metadata" do
+    data = JSON.parse(File.read("benchmark/scoreboard.json"))
+    protocol = data["protocol"]
+    page = File.read("docs/_pages/performance.adoc")
+    block = page[/SCOREBOARD:BEGIN(.*?)SCOREBOARD:END/m, 1]
+
+    expect(block).to include("#{protocol['adapter']} " \
+                             "#{protocol['adapter_version']}"),
+                     "scoreboard metadata does not name the measured engine"
+    expect(block).to include("nokogiri #{protocol['nokogiri']}")
+  end
+end

data/spec/consistency/xpath_idioms_spec.rb

@@ -42,11 +42,6 @@ RSpec.describe "XPath idioms across adapters" do
             Gem::Version.new(Leptris::VERSION) < Gem::Version.new("1.9.359.0")
           skip "binding #{Leptris::VERSION} predates the xmlns: fix (1.9.359)"
         end
-        if adapter_name == :oga
-          # oga's own Ruby XPath engine has no xmlns: default-ns
-          # support (third-party; explicit bindings work).
-          skip "D-01: oga's XPath engine does not implement the xmlns: idiom"
-        end
       end
 
       it "matches default-namespaced elements via the xmlns: prefix" do
@@ -62,6 +57,14 @@ RSpec.describe "XPath idioms across adapters" do
         expect(targets).to be_empty
       end
 
+      it "addresses the no-namespace default with an empty xmlns binding" do
+        doc = ctx.parse(
+          '<root xmlns="urn:a"><child xmlns="urn:b"><leaf xmlns=""/></child></root>',
+        )
+        leaf = doc.at_xpath("//xmlns:leaf", "xmlns" => "")
+        expect(leaf&.name).to eq("leaf")
+      end
+
       it "resolves attribute-terminal steps in every path position" do
         doc = ctx.parse(plain_xml)
         expect(doc.xpath("//a/@id").first&.value).to eq("x")
@@ -118,6 +121,21 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.xpath("boolean(//b)")).to be(true)
         expect(doc.at_xpath("count(//a)")).to eq(1.0)
       end
+
+      # The live-tree contract: a sibling inserted after an XPath
+      # evaluation must be visible to at_xpath and xpath. leptris's
+      # node-set lane caches a document index that sibling insertions
+      # do not rebuild (engine bug, tracked upstream); the adapter
+      # routes such documents to the reference engine until a child
+      # insertion rebuilds the index.
+      it "answers at_xpath and xpath from the live tree after a sibling insertion" do
+        doc = ctx.parse("<r><a><b/></a></r>")
+        doc.xpath("//a")
+        doc.at("//a").next = "<c/>"
+        expect(doc.at("//c")&.name).to eq("c")
+        expect(doc.xpath("//c").map(&:name)).to eq(["c"])
+        expect(doc.at_xpath("count(//c)")).to eq(1.0)
+      end
     end
   end
 end

data/spec/integration/shared_examples/edge_cases.rb

@@ -80,15 +80,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-      if context.config.adapter_name == :libxml
-        skip "LibXML cannot query empty default namespace with XPath (documented limitation)"
-      end
-      if context.config.adapter_name == :nokogiri
-        skip "Nokogiri XPath does not support querying empty namespace with xmlns prefix mapping"
-      end
       xml = <<~XML
         <root xmlns="http://default1.org">
           <child xmlns="http://default2.org">
@@ -103,10 +94,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
 
     it "handles recursive namespace definitions" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-
       xml = <<~XML
         <root xmlns:a="http://a.org">
           <a:child xmlns:a="http://b.org">

data/spec/moxml/adapter/leptris_spec.rb

@@ -184,12 +184,14 @@ RSpec.describe Moxml::Adapter::Leptris do
       end
     end
 
-    it "keeps comments in element serialization with tab units (leptris-ruby#115)" do
+    it "keeps comments in indented serialization with tab units (leptris-ruby#115)" do
       skip "requires the element unit fix (leptris 1.9.50+)" unless described_class::ELEMENT_UNIT_COMMENTS
 
+      # Element-level indentation is loud on this engine (D-09); the
+      # document lane exercises the same generator's unit handling.
       doc = ctx.parse(%(<r><a/><!-- c --></r>))
-      expect(doc.root.to_xml(indent: 1, indent_text: "\t"))
-        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>")
+      expect(doc.to_xml(indent: 1, indent_text: "\t"))
+        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>\n")
     end
 
     it "round-trips document-level PI mutations through serialization" do
@@ -846,4 +848,112 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(first.next_sibling.parent).to eq(doc.root)
     end
   end
+
+  describe "stale-index guard retirement (leptris-ruby#519)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "auto-retires the guard when the engine invalidates its index" do
+      skip "requires an engine whose node-set index survives sibling insertion (leptris-ruby#519)" unless described_class.native_xpath_index_fixed?
+
+      doc = ctx.parse("<r><a/><b/></r>")
+      root = doc.root
+      _ = root.xpath("child::*") # populate the engine node-set index
+      b = root.children.to_a[1]
+      b.add_previous_sibling(doc.create_element("c"))
+
+      native = described_class.native_xpath(root.native, "child::*", nil)
+      expect(native).not_to be_nil
+      expect(native.to_a.map { |n| n.name.to_s }).to eq(%w[a c b])
+    end
+
+    it "never arms the guard on engines that invalidate on splice" do
+      skip "requires an engine whose node-set index survives sibling insertion (leptris-ruby#519)" unless described_class.native_xpath_index_fixed?
+
+      doc = ctx.parse("<root><anchor/></root>")
+      doc.xpath("//ext") # prime the engine index
+      doc.root.add_child(doc.create_element("ext"))
+      expect(doc.xpath("//ext").size).to eq(1)
+
+      expect(
+        described_class.attachments.get(
+          described_class.xpath_index_document(doc.root.native),
+          described_class.singleton_class.const_get(:XPATH_INDEX_STALE),
+        ),
+      ).to be_nil
+    end
+  end
+
+  describe "namespace scope-generation gate" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    # The per-attach scope-generation bump only matters once
+    # namespaces exist; the builder hot path must not pay it.
+    it "does not bump the scope generation while namespaces are absent" do
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      gen = ctx.namespace_scope_generation
+      root.add_child(doc.create_element("a"))
+      root.add_child(doc.create_element("b"))
+      expect(ctx.namespace_scope_generation).to eq(gen)
+      expect(ctx.namespace_scopes_active?).to be(false)
+    end
+
+    it "arms the gate when a write introduces a namespace" do
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      root["xmlns:foo"] = "urn:x"
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(root.namespaces.map { |n| [n.prefix, n.uri] })
+        .to include(%w[foo urn:x])
+    end
+
+    it "is armed by parsed documents" do
+      doc = ctx.parse("<r xmlns:foo='urn:x'><foo:a/></r>")
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(doc.xpath("//foo:a", "foo" => "urn:x").size).to eq(1)
+    end
+
+    it "imports the flag from a foreign context on adoption" do
+      donor_ctx = Moxml.new(:leptris)
+      donor = donor_ctx.parse("<x xmlns:foo='urn:x'/>")
+      doc = ctx.create_document
+      root = doc.create_element("r")
+      doc.root = root
+      expect(ctx.namespace_scopes_active?).to be(false)
+      root.add_child(donor.root)
+      expect(ctx.namespace_scopes_active?).to be(true)
+      expect(root.children.first.namespaces.map(&:uri))
+        .to include("urn:x")
+    end
+  end
+
+  # The README error-handling contract: an invalid element name must
+  # raise Moxml::ValidationError at CREATE time. The adapter's native
+  # fast paths (create_primed_element, create_element_with_attrs) mint
+  # from a name without passing through Base#create_element, where
+  # validate_element_name lives — the failure then surfaced late, at
+  # add_child, as Moxml::Error "Document already has a root element".
+  describe "element name validation on the create seam" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "raises ValidationError when create_element mints an invalid name" do
+      doc = ctx.parse("<root/>")
+      expect { doc.create_element("wrong,name") }
+        .to raise_error(Moxml::ValidationError, /Invalid XML element name/)
+    end
+
+    it "raises ValidationError when add_element mints an invalid name" do
+      doc = ctx.create_document
+      expect { doc.add_element("bad,name", id: "1") }
+        .to raise_error(Moxml::ValidationError, /Invalid XML element name/)
+    end
+
+    it "still mints valid names with punctuation allowed in XML Names" do
+      doc = ctx.parse("<root/>")
+      element = doc.create_element("ns:my-element.v2")
+      expect(element).to be_a(Moxml::Element)
+    end
+  end
 end

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -457,10 +457,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -513,10 +509,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 

data/spec/moxml/attribute_resolver_spec.rb

@@ -31,6 +31,39 @@ RSpec.describe Moxml::AttributeResolver do
       expect(described_class.resolve(element, "z:type")).to be_nil
       expect(described_class.resolve(element, "xmlns:q")).to be_nil
     end
+
+    # Namespaces 1.0 §5.2: the default namespace never applies to
+    # attributes. Engines that resolve unprefixed attributes against
+    # the default namespace must answer nil for it, or bare-name reads
+    # miss on every element under a default namespace.
+    it "never treats bare attributes as default-namespace members" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        d = Moxml.new(adapter_name).parse(%(<r xmlns="urn:a"><e id="1"/></r>))
+        e = d.root.children.find(&:element?)
+        expect(e["id"]).to eq("1"), "#{adapter_name}: bare read"
+        expect(e.attribute("id")&.value).to eq("1"),
+                                            "#{adapter_name}: resolver"
+        expect(e.attribute("id")&.namespace).to be_nil,
+                                                "#{adapter_name}: attribute namespace"
+      end
+    end
+
+    it "keeps bare reads on programmatically built default-namespaced trees" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.create_document
+        root = d.create_element("root")
+        root.add_namespace(nil, "urn:a")
+        d.add_child(root)
+        e = d.create_element("item")
+        e["id"] = "123"
+        root.add_child(e)
+
+        expect(e["id"]).to eq("123"), "#{adapter_name}: bare read"
+        expect(d.xpath('//xmlns:item[@id="123"]').to_a.size).to eq(1),
+                                                                "#{adapter_name}: xmlns predicate"
+      end
+    end
   end
 
   describe ".assign" do

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -59,20 +59,47 @@ RSpec.describe "Moxml::C14n cross-adapter canonicalization" do
   end
 
   describe "document-level nodes keep document order" do
-    # oga surfaces the XML declaration as a <?xml?> PI and keeps the
-    # separator space in PI content (D-04); ox/headed_ox drop PI
-    # content on parse (D-05). Both are pre-existing parse-layer
-    # divergences, out of scope here.
-    let(:adapters) { Moxml::Adapter::AVAILABLE_ADAPTERS - %i[oga ox headed_ox] }
+    # ox/headed_ox drop PI content at parse (D-05), so content-bearing
+    # document-level PIs are pinned on the remaining adapters; the
+    # separator/newline rule itself is pinned on every adapter below
+    # (comments and empty-data PIs are common across all of them).
+    let(:content_adapters) do
+      Moxml::Adapter::AVAILABLE_ADAPTERS - %i[ox headed_ox]
+    end
 
     it "canonicalizes a leading PI before the root element" do
-      adapters.each do |adapter_name|
+      content_adapters.each do |adapter_name|
         doc = Moxml.new(adapter_name)
           .parse(%(<?xml version="1.0"?><?render mode="x"?><doc><e/></doc>))
         expect(Moxml::C14n.canonicalize(doc))
           .to eq(%(<?render mode="x"?>\n<doc><e></e></doc>))
       end
     end
+
+    it "uses exactly one newline between document-level nodes" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?pi?><?pi2?><!--a--><doc/><!--b--><?pi3?>))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<?pi2?>\n<!--a-->\n<doc></doc>\n<!--b-->\n<?pi3?>))
+      end
+    end
+
+    it "never emits the XML declaration" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?xml version="1.0" encoding="UTF-8"?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<doc></doc>")
+      end
+    end
+
+    it "collapses PI separator whitespace to one space" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi  a  b?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc))
+          .to eq(%(<?pi a  b?>\n<doc></doc>))
+      end
+    end
   end
 
   describe "native delegation" do

data/spec/moxml/c14n/character_encoding_spec.rb

@@ -12,25 +12,19 @@ LATIN1_XML = (+"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><r>caf\xE9</r>").
 BOM_XML = (+"\xEF\xBB\xBF<r/>").force_encoding("UTF-8")
 NFC_XML = (+"<r>caf\xC3\xA9</r>").force_encoding("UTF-8")
 
-# oga's parse layer leaks the declaration as a PI node and the BOM as
-# text (pre-existing, documented in the W3C examples spec).
-OGA_LEAK = %i[oga].freeze
-
 RSpec.describe "Moxml character encoding at the parse boundary" do
   Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     context "with the #{adapter_name} adapter" do
       let(:ctx) { Moxml.new(adapter_name) }
 
-      unless OGA_LEAK.include?(adapter_name)
-        it "transcodes declared Latin-1 to UTF-8 bytes" do
-          doc = ctx.parse(LATIN1_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
-        end
+      it "transcodes declared Latin-1 to UTF-8 bytes" do
+        doc = ctx.parse(LATIN1_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
+      end
 
-        it "strips a leading UTF-8 BOM" do
-          doc = ctx.parse(BOM_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
-        end
+      it "strips a leading UTF-8 BOM" do
+        doc = ctx.parse(BOM_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
       end
 
       it "passes NFC content through without normalization" do

data/spec/moxml/c14n/comments_pis_spec.rb

@@ -48,18 +48,45 @@ RSpec.describe "C14N comments and PIs" do
   end
 
   describe "PIs at document level" do
-    # TODO.c14n/09: Document-level PIs (outside the document element) are
-    # not yet rendered correctly. The moxml PI parser mis-parses document-level
-    # PIs, and the DataModel.from_document path drops them. Fixing requires
-    # adapter-level work and is tracked separately.
-    it "renders PIs outside the document element (KNOWN LIMITATION)" do
-      skip "D-08: document-level PI rendering not yet implemented"
+    it "renders PIs outside the document element in document order" do
+      doc = ctx.parse(%(<?pi before?><root><?pi inner?></root><?pi after?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi before?>\n<root><?pi inner?></root>\n<?pi after?>))
+    end
+
+    it "uses exactly one newline between document-level nodes" do
+      doc = ctx.parse(%(<?pi a?><?pi b?><root/><?pi c?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi a?>\n<?pi b?>\n<root></root>\n<?pi c?>))
+    end
+
+    it "ignores whitespace between document-level nodes" do
+      # rexml retains the text node (D-15); the canonical form never
+      # includes whitespace outside the document element.
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi?>\n<root/>\n<!--c-->))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<root></root>\n<!--c-->)), adapter_name.to_s
+      end
+    end
+
+    it "omits the XML declaration from the canonical form" do
+      doc = ctx.parse(%(<?xml version="1.0" encoding="UTF-8"?><root/>))
+      expect(Moxml::C14n.canonicalize(doc)).to eq("<root></root>")
     end
   end
 
   describe "comments at document level" do
-    it "renders document-level comments when with_comments: true (KNOWN LIMITATION)" do
-      skip "D-08: document-level comment rendering not yet implemented"
+    it "renders document-level comments when with_comments: true" do
+      doc = ctx.parse(%(<!--lead--><root><!--inner--></root><!--trail-->))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<!--lead-->\n<root><!--inner--></root>\n<!--trail-->))
+    end
+
+    it "keeps exactly one newline between a document-level PI and comment" do
+      doc = ctx.parse(%(<?pi x?><!--lead--><root/>))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<?pi x?>\n<!--lead-->\n<root></root>))
     end
   end
 end