canon 0.3.116 → 0.3.118

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89df5f303938b98100a1d44399c7eb5fbbf793f0f91c445c4f0533a19234d5ec
-  data.tar.gz: 1308c9228b0a6efc15e81ebef134c7495aadd100e10978a23ee09b92ad558555
+  metadata.gz: 775ec23689366d5e58c5442ad78706027ba7f8e8efba6c06aede93907160f607
+  data.tar.gz: 3f73899302308caf78050f7a692a159cb5e2cc53cbf822e0773c9632bd8beeef
 SHA512:
-  metadata.gz: 93cfb6bca734697c5cc79173dac20bbe53cb4fb17e72fc72e7aa726af366c187c09ae0c30e5a775d9ea8b9e94f1194b29657f9da3d44c58f6fbc116717e39909
-  data.tar.gz: 37f713fb17fe7961cb622f42c96605cf0bb19227a6831018d0505afdc33ad2e315e54b1a65145219457e30d8b0c6d06d001869611bbe94f55b443c2cbf0e4252
+  metadata.gz: fb497832a82755ec47f0314429f58646c7a93be3e6597c226dc605788492db26b985f98923fd87bdac7b9d365724bb5a4907a73ca10255d99edd13621ce2e6da
+  data.tar.gz: 972cf0c38d77cea7dea322430ba681456718c0aed4d153eef40116a438a855c70371289d0d6a74c00a5a3e51e12982d069ede9650e2bc710fd0448e89b8c5f8e

data/CLAUDE.md

@@ -128,18 +128,18 @@ The comparison pipeline flows through four independent layers:
 - `lib/canon/formatters/` — Pretty-printers for canonicalization/formatting (distinct from diff formatters). `XmlFormatter` supports Canonical XML (C14N).
 - `lib/canon/config.rb` — Global configuration with per-format settings (profiles, preprocessing, diff options). Read at runtime via `Canon::Config.instance`.
 - `lib/canon/rspec_matchers.rb` — RSpec matchers (`be_xml_equivalent_to`, `be_json_equivalent_to`, etc.). These delegate to `Canon::Comparison.equivalent?` with the global config. Automatically included in RSpec.
-- `lib/canon/xml/sax_builder.rb` — SAX-based canon-tree builder (~6x faster than DOM parsing for large documents). Engine-neutral; `lib/canon/xml/sax.rb` selects the driver following the resolved adapter (`MoxmlDriver` → leptris SAX under the leptris default, `NokogiriDriver` when the adapter is nokogiri, `MoxmlDriver` under Opal).
+- `lib/canon/xml/sax_builder.rb` — SAX-based canon-tree builder (~6x faster than DOM parsing for large documents). Engine-neutral; `lib/canon/xml/sax.rb` selects the driver following the resolved adapter (`MoxmlDriver` → leptris SAX under the leptris default, `NokogiriDriver` when the adapter is nokogiri).
 
 ### XML Engines
 
 Canon is engine-agnostic across three seams (MECE — one concern per module):
 
-- `Canon::XmlBackend` — XML engine selection. The default follows moxml's resolved adapter: **leptris whenever it is installed** (parse ~1.6x, serialize ~3.8x vs Nokogiri), raw Nokogiri otherwise (wrapping Nokogiri in moxml buys nothing — the wrapper adds 2-3x overhead). `:moxml` under Opal. `CANON_XML_BACKEND=nokogiri|moxml` forces either engine.
+- `Canon::XmlBackend` — XML engine selection. The default follows moxml's resolved adapter: **leptris whenever it is installed** (parse ~1.6x, serialize ~3.8x vs Nokogiri), raw Nokogiri otherwise (wrapping Nokogiri in moxml buys nothing — the wrapper adds 2-3x overhead). Opal is retired (moxml 0.6 deleted the Opal surface, lutaml/moxml#516; the forward path is the moxml-ts wasm binding, lutaml/moxml#489). `CANON_XML_BACKEND=nokogiri|moxml` forces either engine.
 - `Canon::XmlParsing` — the only place that talks to engines for XML parse/serialize (moxml parses pass `readonly: true` — canon never mutates engine documents); node type queries answer for ANY recognized node (Nokogiri or moxml) by type, never by active backend — user-supplied Nokogiri nodes keep working under the moxml engine.
 - `Canon::Html::NokogiriSupport` — HTML engine seam. **HTML is engine-served end-to-end** since 0.3.86-0.3.101: `HtmlParser.parse` routes through moxml `Context#parse_html_fragment` (WHATWG fragment parsing, moxml#353 riding leptris) and builds a Canon tree via the materialize-records fast path — whitespace text nodes survive the parse unconditionally (HTML whitespace significance is the comparison profile's decision, #112/#137), and `parse_node` walks Canon trees directly. The semantic lane's `DataModel.from_html`, the `:format` string normalizer, the canonical HTML formatters, `format_html`'s default/XHTML display modes, and `validate_xhtml!` are all engine-served (0.3.99/0.3.100/0.3.101) — **HTML comparison and formatting run nokogiri-less** (pinned by the optionality contract spec). The Nokogiri HTML fragment path remains only for runtimes without an engine HTML adapter and for user-supplied Nokogiri nodes. Nokogiri's residual roles: the `fixture_ready` display mode (libxml FORMAT|AS_XHTML — moxml#390 filed for an engine XHTML mode), the HTML5 validation lint layer (gumbo error-level classification — leptris#1771 filed), and the fragment-records lane once delivered nil URIs for prefixed attributes (moxml#367, fixed in moxml 0.5.130 — the bulk read now falls back to the reserved-prefix table); the TreeBuilder keeps the one legal `xml`-prefix binding as standing defense.
-- `Canon::Xml::Sax` — SAX driver selection follows the resolved adapter: `MoxmlDriver` (leptris SAX — the comparison hot path, CI-gated in the split flip) under the leptris default, `NokogiriDriver` when the resolved adapter is nokogiri, `MoxmlDriver` under Opal. The builder (`SaxBuilder`) is engine-neutral.
+- `Canon::Xml::Sax` — SAX driver selection follows the resolved adapter: `MoxmlDriver` (leptris SAX — the comparison hot path, CI-gated in the split flip) under the leptris default, `NokogiriDriver` when the resolved adapter is nokogiri. The builder (`SaxBuilder`) is engine-neutral.
 
-Engine parity is complete through libleptris 1.9.8 / leptris-ruby 1.9.33 / moxml 0.5.12: attribute-value normalization, prolog/epilog PIs and comments, DTD ATTLIST defaults off by default (opt-in via `ParseOptions::DTDATTR`), PI-data whitespace matching libxml2, materialize with namespace declarations and a root-subtree-only record contract (moxml#140), readonly parse, deterministic `Document#free` (wired into `from_moxml_xml` — moxml#134). Canon's moxml conversion is record-based (`build_from_moxml` consumes `materialize` records — no per-node wrapper allocation; ~0.55x the Nokogiri conversion). `spec/canon/xml/engine_parity_spec.rb` is fully green. Pretty-printing runs the leptris serializer through `PrettyPrinter::Xml#moxml_format` (byte parity via moxml#153/#155/#156; the #167 escaping race fixed in 0.5.28), with Nokogiri serving the fallback engine and Opal — pretty-printed bytes are canon's product, gated by the fixture-integrity suite and the CI performance gate.
+Engine parity is complete through libleptris 1.9.8 / leptris-ruby 1.9.33 / moxml 0.5.12: attribute-value normalization, prolog/epilog PIs and comments, DTD ATTLIST defaults off by default (opt-in via `ParseOptions::DTDATTR`), PI-data whitespace matching libxml2, materialize with namespace declarations and a root-subtree-only record contract (moxml#140), readonly parse, deterministic `Document#free` (wired into `from_moxml_xml` — moxml#134). Canon's moxml conversion is record-based (`build_from_moxml` consumes `materialize` records — no per-node wrapper allocation; ~0.55x the Nokogiri conversion). `spec/canon/xml/engine_parity_spec.rb` is fully green. Pretty-printing runs the leptris serializer through `PrettyPrinter::Xml#moxml_format` (byte parity via moxml#153/#155/#156; the #167 escaping race fixed in 0.5.28), with Nokogiri serving the fallback engine — pretty-printed bytes are canon's product, gated by the fixture-integrity suite and the CI performance gate.
 
 Engine A/B testing: `CANON_XML_BACKEND=nokogiri bundle exec rspec` (or `=moxml` to force leptris when it isn't the resolved default). The default suite must stay green under BOTH values; the only expected pendings are the upstream-tracked ones. The benchmark header (`rake performance:quick`) reports the active engine.
 

data/Rakefile

@@ -5,50 +5,10 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-begin
-  require "opal/rspec/rake_task"
-
-  # Configure Opal load paths at load time (same pattern as moxml)
-  if defined?(Opal)
-    Opal.append_path File.expand_path("lib", __dir__)
-
-    # moxml gem
-    begin
-      moxml_spec = Gem::Specification.find_by_name("moxml")
-      moxml_lib = moxml_spec.full_require_paths.first
-      Opal.append_path moxml_lib
-      moxml_compat = File.expand_path("compat/opal", moxml_lib)
-      Opal.append_path moxml_compat if File.directory?(moxml_compat)
-    rescue Gem::MissingSpecError
-      # moxml not installed
-    end
-
-    # REXML: bundled gem since Ruby 3.4
-    rexml_lib = $LOAD_PATH.find do |p|
-      File.exist?(File.join(p, "rexml", "document.rb"))
-    end
-    Opal.append_path rexml_lib if rexml_lib
-  end
-rescue LoadError
-  # Opal not available or incompatible with current Ruby version
-end
-
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
 Dir.glob("lib/tasks/**/*.rake").each { |r| load r }
 
-namespace :spec do
-  if defined?(Opal::RSpec::RakeTask)
-    desc "Run Opal (JavaScript) tests"
-    Opal::RSpec::RakeTask.new(:opal) do |_server, runner|
-      runner.default_path = "spec"
-      runner.requires = %w[rexml_compat rexml/document rexml/xpath
-                           moxml moxml/adapter/rexml spec_helper]
-      runner.pattern = "spec/canon/opal_xml_smoke_spec.rb"
-    end
-  end
-end
-
 task default: %i[spec rubocop]

data/docs/HANDOFF.adoc

@@ -0,0 +1,178 @@
+---
+published: false
+---
+= Cross-team handoff: the engine issue board
+
+A snapshot of the open arcs across the org repos — what is known, where
+to dig, and what has already been proven — so any team can pick an issue
+up cold. Statuses as of 2026-10-28.
+
+== lutaml/moxml
+
+[cols="1,1,2"]
+|===
+|Issue |Status |Known + first moves
+
+|moxml#474 — parent-of-attribute (`./@id/..`) returns empty through the
+Ruby engine on the leptris adapter
+|Open (filed 2026-10-27 with probes)
+|The adapter routes parent-axis expressions to the Ruby engine
+(`REVERSE_AXES` in `adapter/leptris.rb`); that lane loses attribute
+inputs. The ENGINE answers correctly since leptris v1.9.385 (both eval
+paths). Easiest: widen the native gate for parent/ancestor-after-
+attribute paths; or fix `on_axis_parent` in `xpath/compiler.rb` for
+`Wrappers::Attribute` inputs (the wrappers carry `@parent_node`).
+Unblocks metanorma-standoc's `svg_uniqueids1`.
+
+|moxml#472 — `.//*[@class]` predicate segfaults the compiled evaluator
+|Open
+|Crash in `leptris_xpath_compiled_eval` (.ips on file); the
+`attribute::class` spelling does not crash. FIRST retest against
+leptris v1.9.385 — a corrupt-attribute-table class (the cross-doc
+adopt, leptris#1869) shipped fixed there and could be the fuel. If it
+still crashes: the VM's predicate lane (`src/leptris/xpath/vm.c`,
+attribute existence inside `[...]`). Production hit: standoc's
+`svg_classupdate1`.
+
+|moxml#473 — XSD compile of large occurrence products grows unbounded
+(jetsam SIGKILL, low RSS)
+|Open
+|W3C `particlesZ034_b.xsd` repro in the issue. The compiled automaton's
+product construction needs cardinality folding (`unbounded` inner terms
+to epsilon-loops) instead of enumeration.
+|===
+
+== leptris/leptris
+
+[cols="1,1,2"]
+|===
+|Issue |Status |Known + first moves
+
+|leptris#1866 — cross-doc replace + `@id/..` + serialize
+|CLOSED (v1.9.385, #1869)
+|Shipped: the adopt copy's attribute-tail resync
+(`copy_subtree_detached`, `src/leptris/dom/element_modify.c`) and the
+evaluator-path parent-of-attribute (`apply_axis`,
+`src/leptris/xpath/evaluator_axes.c`). Pin:
+`AdoptKeepsMixedPlainAndNamespacedAttrs`. Re-verify downstream crash
+reports (moxml#472) against 1.9.385.
+
+|leptris#1842 — C-face XML parse/gen/xpath ~3-4x behind pugixml
+|Open
+|Decomposed into #1846/#1854/#1855. Use the interleaved A/B harness.
+
+|leptris#1846 — parse gap is allocator-shaped (1.0x mingw -> 4.3x old
+Intel mac, same code)
+|Open, slice 3 pending
+|Allocation profile done (the issue's wave comment). ARENA
+RIGHT-SIZING with the interleaved harness — cross-wave comparison is
+INVALID (pugixml swung 1.7x between waves; only within-run interleaved
+A/B counts). A counting-malloc interposer via `DYLD_INTERPOSE` beats
+xctrace for parse loops. Prior art: `leptris-xsitype` worktree,
+branch `perf/1846-adopt-conversion-buffer`.
+
+|leptris#1854 — `to_xml` native emission: `FFI::Pointer#+` is 37% of
+the loop
+|Open
+|An address-Integer emission API (`uintptr_t` in/out, the #408 law);
+batch per subtree, not per node.
+
+|leptris#1855 — plan-path parse ~35% FFI materialization
+|Open
+|Batched child/string asks; mirror the `children_read` bulk face
+(leptris-ruby#530).
+|===
+
+== leptris/yeptris
+
+[cols="1,1,2"]
+|===
+|Issue |Status |Known + first moves
+
+|yeptris#739 — JSON parse 2x behind yyjson
+|Open
+|The 12x WRITE gap is closed (serialize 16->221 MB/s: the one-pass
+route, the run-batched `emit_dq_json` SWAR scan, the `emit_json_value`
+walker). Parse remains; profile with the counting-malloc interposer.
+
+|yeptris#742 — YAML emit ~1.5x behind rapidyaml; CBOR decode 1.3-2.2x
+behind tinycbor
+|Open
+|13-leg matrix. The emit side shares machinery with the closed #739
+write work — reuse the walker patterns.
+
+|yeptris#474 — `parse_json_tape` 0.61x vs simdjson on arm64 (ubuntu
+1.07x, same binary)
+|Open
+|Platform-specific: diff the arm64 SIMD kernels vs the scalar fallback
+(`src/yeptris/common/simd_text*`), starting from the kernel-selection
+law.
+
+|yeptris#352 — yaml generation 1.4-1.7x behind rapidyaml (10/12
+platforms)
+|Open, partially improved
+|Remaining: scalar-route derivation cost. `benchmarks/PERF-LEDGER.md`
+has the trusted-into entries.
+|===
+
+== leptris/yeptris-ruby
+
+[cols="1,1,2"]
+|===
+|Issue |Status |Known + first moves
+
+|yeptris-ruby#322 — CBOR dump is marshaling-bound
+|Open
+|The JSON half shipped (the marshal face: 4.4x end-to-end). CBOR: a
+`yeptris_cbor_from_marshal`-style face, reusing the marshal reader's
+REGISTRY LAW and its pin (`test/unit/test_marshal_json.cpp`) — the
+registry law (who occupies an `@` slot) is the hard-won part; copy both.
+|===
+
+== Mechanics every team hits
+
+[cols="1,3"]
+|===
+|Topic |The law
+
+|Differential corpora
+|Random-tree corpora never produce repeated keys or shared references —
+shift/registration bugs survive 300/300 "green". Include linked shapes
+(users-style rows). Lock byte-level fixtures to FILES (Ruby's fstring
+interning varies per process).
+
+|Performance claims
+|Cross-wave serialbench comparison is INVALID (runner noise; pugixml
+swung 1.7x between waves). Only within-run interleaved A/B on fresh
+binaries counts. The perf gate is best-of-N per side.
+
+|Release cuts (yeptris)
+|`next_version` must be a LITERAL X.Y.Z. The release PR self-closes ~2
+min after cut if checks never start: push a PARENTED trigger commit
+(`git commit-tree -p "$sha" -m ... "$sha^{tree}"` — without `-p` the
+commit orphans and the PR creation fails) within the window, then
+approve runs gated at `conclusion == "action_required"` (the `status`
+field reads `completed` while gated). The changelog gate requires an
+`## [Unreleased]` section before EVERY cut, version-only ones included.
+
+|Release cuts (yeptris-ruby)
+|RELEASE_TOKEN unset -> the bump job's 60-min wait step always fails;
+the PR opens anyway. Hand-merge on green, then dispatch the republish
+with EMPTY next_version (reuses main's VERSION). A new gem version needs
+its C `v<c_semver>` tag to EXIST first (platform legs vendor from it).
+
+|Release cuts (leptris)
+|The same cut/trigger/approve cycle; the Unreleased section exists on
+main — keep it fed.
+
+|Formatting
+|The repos target clang-format 14+ (CI runs LLVM 18); local 11.1/22.1
+both reject the config — the CI format job is the gate.
+
+|CI flakes
+|`pull_request` events intermittently vanish for fresh PRs (yeptris,
+leptris). Fallback: `gh workflow run test.yml format.yml asan.yml --ref
+<branch>` — sha-keyed check runs satisfy required-context protection.
+A "failed" check may be CANCELLED by a concurrent push (concurrency
+groups) — read the conclusion, `gh run rerun <id> --failed`.
+|===

data/docs/_references/canonical-digests.adoc

@@ -0,0 +1,50 @@
+= The canonical digests (W5.3)
+
+This document specifies canon's canonical digest API as shipped by
+`Canon::Digest`. Reviewed against the implementation by
+`spec/canon/docs/canonical_digests_spec.rb` (the W6.3 review-gate
+pattern), with the cross-release byte pins carried by
+`spec/canon/digest_stability_spec.rb`.
+
+== 1. The law
+
+The digest of a document is the OpenSSL hash of its CANONICAL
+FORM — the form under which the format's comparison pipeline deems
+documents equivalent. Two documents that compare equivalent produce
+identical digests; two that compare distinct produce distinct
+digests. The digest is an API over the comparison semantics, not a
+new canonicalization.
+
+== 2. Per-format canonical forms
+
+* *XML* rides Canonical XML 1.1
+  (`Canon::Xml::C14n.canonicalize`, reached as
+  `Formatters::XmlFormatter.format(pretty: false)`). The
+  pretty-printed XML form preserves attribute order and is NOT
+  canonical; the digest lane never touches it.
+* *JSON and YAML* ride the key-sorted formatter forms (the JCS
+  profile for JSON's canonical lane; the `[class, to_s]` TOTAL
+  key order for YAML).
+* *HTML* rides the whitespace-law form with sorted attributes
+  (the W1.3 specification).
+
+Equivalence consequences the digest inherits: attribute order is
+insignificant in XML and HTML; mapping key order is insignificant
+in JSON and YAML; element/sequence order is significant everywhere.
+
+== 3. Entry points
+
+`Canon::Digest.digest(content, format, algorithm: "sha256")`
+accepts any OpenSSL digest name; `canonical_form(content, format)`
+exposes the hashed bytes. Per-format shorthands
+(`Canon.digest_xml`, `digest_yaml`, `digest_json`, ...) mirror the
+format lane's shorthands.
+
+== 4. Stability contract
+
+The digests are stable across releases for as long as the
+underlying canonical form is. The stability suite pins the digest
+hex of a representative document per format; a canonical-form
+change moves a digest and MUST fail that suite, forcing a
+conscious pin update (and a release note) rather than silent drift
+for downstream dedup stores.

data/docs/_references/jcs-rfc8785.adoc

@@ -0,0 +1,52 @@
+= The JCS canonical profile (W6.1, RFC 8785)
+
+This document specifies canon's JSON JCS canonical form as shipped
+by `Canon::Json::JCS`. Reviewed against the implementation by
+`spec/canon/docs/jcs_spec_review.rb` (the W6.3 review-gate
+pattern).
+
+== 1. Scope
+
+RFC 8785 — the I-JSON Canonicalization Scheme. Input must be I-JSON
+(RFC 7493): valid UTF-8 without lone surrogates, no duplicate
+object keys, numbers expressible as IEEE 754 doubles. Violations
+raise `Canon::Json::JCS::Error`.
+
+== 2. The canonical laws
+
+* *Strings* (`escape_string`): RFC 8785 §3.2.2.2 — the
+  JSON.stringify escaping set: short forms for `\b \t \n \f \r`
+  (the SHORT_ESCAPES table), two-hex lowercase `\u00xx` for the
+  remaining C0 controls, `\"` and `\\`; every other code point
+  emits verbatim as UTF-8 (DEL U+007F is NOT escaped).
+
+* *Numbers* (`es6_number`): ECMAScript `Number::toString`
+  serialization — the shortest round-tripping decimal, fixed
+  notation inside [1e-6, 1e21), exponential outside; integers
+  via `ijson_integer` (the I-JSON 2^53 range).
+
+* *Object keys* (`write_object`): sorted by their
+  UTF-16 code units (`utf16_code_units` — the RFC's sort is over
+  UTF-16 code units, not code points, so surrogate pairs and BMP
+  characters interleave per the RFC's examples; e.g. the key
+  U+1D160 (a surrogate pair, code units 0xD834 0xDD60) sorts
+  BEFORE U+20AC (a single BMP code unit 0x20AC), which sorts
+  BEFORE "a" (0x0061)).
+
+* *Containers*: arrays comma-separated in order; objects
+  comma-separated in sorted key order; no whitespace anywhere.
+
+== 3. Entry points
+
+`canonicalize(json)` accepts a JSON string (parsed through
+`JSON.parse`) or an already-parsed Ruby graph; `serialize(value)`
+skips the parse. The canonical form is byte-stable across
+platforms and suitable for hashing and signing.
+
+== 4. Fixed point and parity
+
+JCS output re-parses to the same graph, and the form is a fixed
+point. The phase 02 property suite (JSON/YAML equivalence legs)
+and the diff-display corpus pin the behavior; the JCS spec
+vectors (RFC 8785 §3.2.3 examples) pin the number and sorting
+laws.

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.116"
+  VERSION = "0.3.118"
 end

data/lib/canon/xml/exclusive_c14n.rb

@@ -55,12 +55,30 @@ module Canon
       # — every node in the subtrees rooted at pfx:name. Returns
       # [prefix, local_name], or nil for anything else.
       def self.c14n_selection_idiom(xpath)
-        # the suite's .xpath files are XML documents wrapping the
-        # expression (with prefix declarations and inline comments)
-        text = xpath.sub(/\A<\?xml[^?]*\?>/, "")
-          .gsub(/<!--[\s\S]*?-->/, "")
-          .gsub(/<[^>]*>/, " ")
-          .squeeze(" ")
+        # The suite's .xpath files are XML documents wrapping the
+        # expression (with prefix declarations and inline comments).
+        # Extraction is index-based string surgery — the CodeQL
+        # polynomial-redos query flags the gsub-chain form.
+        close_tag = xpath.rindex("</XPath>")
+        text = close_tag ? xpath[0...close_tag] : xpath.dup
+        # drop the XML declaration and the <XPath> open tag: each
+        # ends at the first '>' at/after its '<'
+        if (decl = text.index("<"))
+          gt = text.index(">", decl)
+          if (xopen = text.index("<XPath", decl)) && (xopen < gt)
+            gt = text.index(">", xopen)
+          end
+          text = text[(gt + 1)..] if gt
+        end
+        # strip <!-- --> comments by index (no regex backtracking)
+        loop do
+          open_c = text.index("<!--")
+          break unless open_c
+
+          close_c = text.index("-->", open_c + 4)
+          text = close_c ? text[0...open_c] + text[(close_c + 3)..] : text[0...open_c]
+        end
+        text = text.squeeze(" ")
         m = text.match(%r{\(//\.\s*\|\s*//@\*\s*\|\s*//namespace::\*\)\s*\[\s*ancestor-or-self::([A-Za-z_][\w.-]*)(?::([\w.-]+))?\s*\]\s*\z})
         return nil unless m
 

data/lib/tasks/performance_comparator.rb

@@ -30,16 +30,33 @@ class PerformanceComparator
   DIM    = "\e[2m"
   CLEAR  = "\e[0m"
 
+  BEST_OF = Integer(ENV.fetch("CANON_PERF_BEST_OF", "3"))
+
   def run
     clone_base
-    current = run_report(REPO_ROOT, "current")
-    base = run_report(base_clone_dir, "base (#{DEFAULT_BASE})")
+    current = best_of(REPO_ROOT, "current")
+    base = best_of(base_clone_dir, "base (#{DEFAULT_BASE})")
     print_report(current, base)
     exit(1) if regressions?(current, base)
   ensure
     cleanup
   end
 
+  # The html_parsing lanes drift up to ~27% BETWEEN SAME-CONTENT runs
+  # on shared runners (main failed against itself: run 40047205814) —
+  # single-run comparisons measure the runner, not the code. Each side
+  # runs BEST_OF times; per benchmark, the run with the highest upper
+  # bound stands (the capability estimate a fair gate compares).
+  def best_of(working_dir, label)
+    runs = Array.new(BEST_OF) { |i| run_report(working_dir, "#{label} ##{i + 1}") }
+    runs.first.fetch("benchmarks").keys.each_with_object({}) do |bench, merged|
+      best = runs.max_by { |r| r.fetch("benchmarks").fetch(bench).fetch("upper").to_f }
+      merged[bench] = best.fetch("benchmarks").fetch(bench)
+    end.then do |benchmarks|
+      runs.first.merge("benchmarks" => benchmarks)
+    end
+  end
+
   private
 
   def clone_base

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.116
+  version: 0.3.118
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.376
+        version: 1.9.398
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.376
+        version: 1.9.398
 - !ruby/object:Gem::Dependency
   name: moxml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.149
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.149
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.32
+        version: 0.6.52
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.32
+        version: 0.6.52
 description: |-
   Canon provides canonicalization and pretty-printing for various serialization
   formats (XML, HTML, JSON, YAML), producing standardized forms suitable for
@@ -171,10 +171,13 @@ files:
 - Rakefile
 - docs/.lycheeignore
 - docs/Gemfile
+- docs/HANDOFF.adoc
 - docs/INDEX.adoc
 - docs/_config.yml
+- docs/_references/canonical-digests.adoc
 - docs/_references/comparison-theory.adoc
 - docs/_references/html-canonical-form.adoc
+- docs/_references/jcs-rfc8785.adoc
 - docs/_references/yaml-canonical-form.adoc
 - docs/advanced/diff-classification.adoc
 - docs/advanced/diff-pipeline.adoc