leptris 1.9.290.0-aarch64-linux → 1.9.302.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aba6a98f4741c3dd716f07900afb75f08b0601872231c42ed078749c5e03384
-  data.tar.gz: 9cf9b759a9689a6905f77db7af148ae3142c25c83815553c5a60e5f57fefac0a
+  metadata.gz: f0c0acc96d46fa6c52961fa5ea4f896f9ed9ca895125ffda6ad474ab6b7f4cb2
+  data.tar.gz: 1d933d9a8ce4c210ba9ca03e68216625ed41e3d9122d1c7eb449ce374910951e
 SHA512:
-  metadata.gz: 609d86b94c6fa03ebdba443ccb11c8688c836c73294079470b0ded0dc127df8010d438d1d6c87b06a46fb3bdb690e4b498b1716da0fee266c05a3da6b6bb30ee
-  data.tar.gz: 874f8aea390b65d105d756318f19149cc230003bdd3f055aa95ebe7d7986e9ba8df21dc4514533ee60c2e87db83091599493a5df759d828d024353e4f0338c0e
+  metadata.gz: fdfbb09db03c6e7757ab9f3fecb94fede0840456cde6830f20861e41e17ae71d13acc98bb31b130d923127a73c60fa5d25702d51ade8c535c20a1791f884ca68
+  data.tar.gz: 0bc734310aef6db4743e0c36f4e33d4f66315e28df973a0ef9eb9157d9714bdacdd9729571ed4648cf613a04ca666bcbd91468dd51fe21d1e806f48ba4e2a674

data/CHANGELOG.md

@@ -1,3 +1,101 @@
+## [1.9.302.0] - 2026-10-05
+
+### Engine sync (libleptris 1.9.293-1.9.302)
+
+Ten upstream releases ride in this pin — internal fixes and
+performance with NO binding-surface changes (zero header deltas
+292..302; the audit gate confirms 363/362 unchanged). Highlights:
+
+- **XQuery correctness**: a false() bound anywhere read as truthy;
+  fn:not uses the effective boolean value; fn:abs(()) is empty;
+  string lt/gt are codepoint comparisons; fn:avg edge shapes;
+  aggregates atomize array arguments; `instance of xs:integer`
+  demands integrality; xs:byte/unsignedByte/unsignedInt
+  constructors; fn:sum#2's zero argument.
+- **Collation**: UCA over the vendored DUCET table (slices 1-4) —
+  fn:normalize-unicode F&O conformance, collation-aware string
+  functions, 71+1078 QT3 cases adopted, implicit weights and
+  alternate=blanked.
+- **Performance**: per-thread recycle of mutation blocks (DOM
+  create/build/free).
+- **Rust bindings**: first tokenless crates.io release (leptris
+  v1.4.1) from CI.
+
+## [1.9.292.0] - 2026-10-03
+
+### Fixed
+
+- **Document#root= adopts foreign roots (leptris-ruby#371)**:
+  vendored 1.9.292 (engine #1495) — a foreign element is no longer
+  rejected with EINVAL; the subtree is deep-copied into this
+  document's pool (all node kinds, attributes, namespace
+  declarations), the source document loses the element, and the
+  detached original stays resolvable until the source frees. The
+  binding routes cross-document installs through the new
+  leptris_document_set_root_ex and wraps the INSTALLED handle — a
+  fresh pointer, not the source. Same-document installs keep the
+  native fast path. The old "rejects foreign" construction spec now
+  pins adoption.
+
+## [1.9.291.0] - 2026-10-03
+### Fixed
+
+- **Removed nodes leave clean orphans (leptris-ruby#370)**:
+  vendored 1.9.291 — `remove_child` / `remove_all_children` clear
+  the removed nodes' own sibling links, so a later re-append never
+  splices the stale sibling run into the new parent (nodes were
+  reachable from two parents, up to self-containing cycles).
+- **`prefix:*` is namespace-scoped (leptris-ruby#368)**: three
+  fused compiler sites lowered `//m:*` to the any-element opcode;
+  prefixed wildcards now resolve through the caller's bindings.
+
+### Added
+
+- **Descriptor row-layout skew gate (engine #1490 follow-up)**:
+  the five new struct-size accessors are attached and the
+  descriptor face verifies the engine's compiled row sizes against
+  the binding's FFI structs before every plan build — version
+  skew fails loudly instead of misparsing rows.
+
+## [1.9.290.0] - 2026-10-02
+
+### Fixed
+
+- **Params values evaluate as XPath expressions (engine 1.9.288,
+  #1481 semantics correction)**: the #360 face shipped briefly on
+  raw-string binding — under libleptris 1.9.288+ the value strings
+  evaluate as XPath EXPRESSIONS, the libxslt `params` convention
+  callers know from nokogiri (whose quote_params exists to add the
+  quotes): `"4 * 3"` binds 12, `"'S'"` binds the string `"S"`,
+  `string(/r/@v)` reads the source, a malformed expression fails
+  the transform. The face docs and specs updated to the corrected
+  contract; callers passing pre-quoted values (nokogiri-style)
+  are already correct.
+
+### Added — engine sync (1.9.290)
+
+- Namespace forms for attribute plan rows: `ns_form` / `ns_uri`
+  on the descriptor AttrPlan (#1486/#1487) — the binding packs the
+  fields (zero = the historical wire-name lookup); exposing
+  ns-exact rows from plan trees lands with the first consumer.
+
+### Performance — engine sync (1.9.288-1.9.289)
+
+- Vendored libleptris 1.9.288-1.9.289: the #1481 params semantics
+  correction, plus the 289 HTML-path performance work (slice 6 of
+  #1218): open-id integer compares for the scope/table-context
+  stack walks and id-LUT membership for the foster/formatting
+  checks — cumulative ~+15% on the table-rows fixture; the
+  3.4-7x deficit at 1.9.203 is now a 1.3-1.55x lead over
+  htmlReadMemory.
+- **Descriptor AttrPlan ABI adoption (#1486)**: the attribute-row
+  plan struct gains trailing ns-form fields (additive to the
+  frozen v1 ABI — the #1115 pattern). The binding packs the full
+  layout (FFI zero-fill keeps unset = the historical wire-name
+  lookup); riding 1.9.288+ without the extension reads past the
+  allocation and segfaults the descriptor face. Namespace-form
+  attribute rows are engine-ready; the binding face follows.
+
 ## [1.9.287.0] - 2026-10-02
 
 ### Added

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.290"
+LIBLEPTRIS_VERSION = "1.9.302"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.290.0"
+  VERSION = "1.9.302.0"
 end

data/lib/leptris/xml/descriptor.rb

@@ -96,6 +96,25 @@ class Leptris::XML::Descriptor
   # Ruby-side spec memory is transient (the engine deep-copies).
   def self.build(tree)
     abi = Leptris::XML::FFI.leptris_plan_abi_version
+    # Row-layout skew gate (1.9.291, engine #1490 follow-up): the
+    # engine reports its compiled row sizes; a mismatch means the
+    # binding's FFI structs and the vendored engine disagree —
+    # fail loudly instead of misparsing rows.
+    {
+      Leptris::XML::FFI.leptris_plan_spec_struct_size => Leptris::XML::FFI::PlanSpec,
+      Leptris::XML::FFI.leptris_plan_element_row_size => Leptris::XML::FFI::ElementPlan,
+      Leptris::XML::FFI.leptris_plan_child_row_size => Leptris::XML::FFI::ChildPlan,
+      Leptris::XML::FFI.leptris_plan_attr_row_size => Leptris::XML::FFI::AttrPlan,
+      Leptris::XML::FFI.leptris_plan_predicate_row_size =>
+        Leptris::XML::FFI::AttrPredicate
+    }.each do |engine_size, struct|
+      next if engine_size == struct.size
+
+      raise Leptris::XML::Error,
+        "descriptor row-layout skew: engine #{engine_size}B vs " \
+        "binding #{struct.size}B for #{struct.name} — the vendored " \
+        "engine and the binding structs disagree"
+    end
     if abi != Leptris::XML::FFI::PLAN_ABI_VERSION
       raise Leptris::XML::Error,
         "descriptor ABI v#{abi} != binding v#{Leptris::XML::FFI::PLAN_ABI_VERSION}"

data/lib/leptris/xml/document.rb

@@ -384,7 +384,20 @@ class Leptris::XML::Document
     # TODO.perf/33: gates + bump + engine set_root in one C
     # dispatch (the FFI call plus the c_ptr materialization fed
     # ~5% of a fresh-doc build).
-    if defined?(Leptris::XML::NATIVE_FAST)
+    # Cross-document adoption (1.9.292, #371): the engine DEEP-COPIES
+    # the foreign subtree into this document's pool and reports the
+    # installed element — a fresh handle distinct from the source
+    # pointer. Same-document installs keep the native fast path.
+    cross = element.document && !element.document.equal?(self)
+    installed_ptr = nil
+    if cross
+      out = ::FFI::MemoryPointer.new(:pointer)
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::FFI.leptris_document_set_root_ex(
+          c_ptr, element.c_ptr, out))
+      installed_ptr = out.read_pointer
+      @version += 1
+    elsif defined?(Leptris::XML::NATIVE_FAST)
       Leptris::XML::Native.set_binding_root(self, element.c_address)
     else
       Leptris::XML::FFI.check_status(
@@ -394,7 +407,7 @@ class Leptris::XML::Document
     # Seed the root memo through wrap: a cross-document element
     # must enter THIS document's identity cache with @document
     # pointing here, not ride its source-document wrapper.
-    @root = Leptris::XML::Node.wrap(element.c_ptr, self)
+    @root = Leptris::XML::Node.wrap(installed_ptr || element.c_ptr, self)
     @root_version = @version
     Leptris::XML::Node.invalidate_cross_document!(element, self)
     element

data/lib/leptris/xml/ffi.rb

@@ -300,9 +300,10 @@ module Leptris
                :predicate_count, :uint16,
                :pad_pred, :uint16,
                :predicates, :pointer,
-               # libleptris 1.9.289 (#1486): attribute-level namespace
-               # form — ns rows match by (URI, local), wire_name is the
-               # LOCAL name; NONE keeps wire-name-exact matching.
+               # libleptris 1.9.289 (#1486): attribute-level ns
+               # form (additive trailing to the frozen v1 ABI —
+               # the #1115 child-row pattern). FFI zero-fills, so
+               # unset = the historical wire-name lookup.
                :ns_form, :uint8,
                :pad_ns, :uint8,
                :ns_uri, :pointer
@@ -372,6 +373,15 @@ module Leptris
       attach_function :leptris_node_byte_offset,
         [:leptris_node_ref], :size_t
 
+      # Struct-size accessors (1.9.291, engine #1490 follow-up):
+      # the engine's compiled row layouts — the descriptor face
+      # verifies them against the FFI structs it packs and fails
+      # loudly on version skew instead of misparsing rows.
+      attach_function :leptris_plan_spec_struct_size, [], :size_t
+      attach_function :leptris_plan_element_row_size, [], :size_t
+      attach_function :leptris_plan_child_row_size, [], :size_t
+      attach_function :leptris_plan_attr_row_size, [], :size_t
+      attach_function :leptris_plan_predicate_row_size, [], :size_t
       attach_function :leptris_plan_abi_version, [], :uint32
       attach_function :leptris_plan_build,
         [:pointer, :pointer], :leptris_plan
@@ -484,6 +494,12 @@ attach_function :leptris_parse_string,
         [], :leptris_document
       attach_function :leptris_document_set_root,
         [:leptris_document, :leptris_element], :leptris_status
+      # 1.9.292 (#371): foreign roots are ADOPTED — deep-copied into
+      # this document's pool; out_installed reports the fresh
+      # handle (wrap THAT, not the source pointer). Legacy
+      # set_root adopts too but cannot report the installed node.
+      attach_function :leptris_document_set_root_ex,
+        [:leptris_document, :leptris_element, :pointer], :leptris_status
       attach_function :leptris_document_root,
         [:leptris_document], :leptris_element
       # The document node — navigation head over the whole tree

data/lib/leptris/xml/xslt.rb

@@ -69,11 +69,13 @@ module Leptris::XML::XSLT
     # Apply to +document+ (not modified) and return the result tree
     # as an owning Document — query it with xpath/css like any other.
     #
-    # params (#360): top-level xsl:param overrides as a Hash of
-    # name => value. Values bind as XPath STRINGS verbatim — the
-    # caller owns numeric/boolean quoting (libxslt conventions:
-    # pass '7' for a number, matching nokogiri's quote_params).
-    # Absent names keep the param's select/@default.
+    # params (#360, engine 1.9.288 semantics): top-level xsl:param
+    # overrides as a Hash of name => value. Values evaluate as
+    # XPath EXPRESSIONS — the libxslt `params` convention callers
+    # know from nokogiri (whose quote_params exists to add the
+    # quotes): "7 * 6" binds 42, "'7'" binds the string "7",
+    # "string(/r/@v)" reads the source. A malformed expression
+    # fails the transform. Absent names keep select/@default.
     def apply_to(document, params: nil)
       raw, buffer, = with_param_pairs(params) do |pairs, count|
         if pairs

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.290
+- libleptris v1.9.302
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,391 @@
 ## [Unreleased]
 
+## [1.9.302] - 2026-10-04
+
+### Added
+
+- **XQuery: aggregates atomize array arguments** — `fn:avg`,
+  `fn:sum`, `fn:min` and `fn:max` take `xs:anyAtomicType*`, so a
+  dense array argument now contributes its members instead of
+  leaking the internal carrier: `avg([1,2,3,4,5])` = 3,
+  `sum([1,2,3,4,5])` = 15 (fn-avg-10, fn-sum-11, fn-min-19,
+  fn-max-19). A new shared decoder turns carriers keyed exactly
+  1..n into positional members, recursing into nested arrays
+  (`[[1,2],[3]]` → 1,2,3); maps and sparse carriers stay single
+  items, and `item()`-typed functions such as `fn:count` still see
+  an array as one item, per XDM. `fn:sum`'s per-item accumulation
+  moved into a helper so atomized members feed the existing
+  int64-exact and xs:float channels unchanged.
+- **XQuery: `instance of` over the integer family demands
+  integrality** — `xs:integer` and its derived types
+  (int/long/short/byte/unsigned*/nonNegative…) now require an
+  integral value on both the sequence-member and scalar paths:
+  `fn:abs(1.1) instance of xs:integer` is false,
+  `fn:abs(-3) instance of xs:integer` is true.
+
+### Fixed
+
+- **XQuery: `fn:avg` edge shapes** — `avg(())` returns the empty
+  sequence under XQuery (XPath 1.0 parity untouched), and averages
+  over `xs:yearMonthDuration` format through the shared months
+  formatter (cbcl-avg-006: `P1Y`). Also freed a nested-array
+  carrier on an allocation-failure path in the atomizing decoder.
+- QT3 re-pins from one verified run: fn/avg 164→173, fn/max
+  165→167, fn/min 165→167, fn/sum 203→204 (+14 adopted cases;
+  total pins 1134 → 1148; 61/61 suites green).
+
+
+
+## [1.9.301] - 2026-10-04
+
+### Fixed
+
+- **XQuery: a false() bound anywhere read as truthy** — values
+  stringified to a marker-less "false" that every effective-boolean-
+  value site saw as a non-empty string, so `let $x := false() return
+  if ($x)...` took the then-branch and fold accumulators ignored a
+  false() zero (fold-left-004). Variable bindings, local:function
+  thunk arguments and the fold accumulators/items now carry the
+  boolean type marker; the EBV read honors it on singleton synthetic
+  members (XML 1.0 forbids raw control characters in text content,
+  so the marker cannot collide with document data); named-reference
+  closure calls spell marked booleans back to literals; both string
+  consumers render them as true/false. (PR #1522)
+
+- **fn:not uses the effective boolean value** — not(false()) is
+  true while fn:empty((false())) stays false; real nodes keep the
+  XPath 1.0 existence rule, so libxml2 parity is unchanged.
+  (PR #1522)
+
+- **fn:abs(()) is the empty sequence** under the XQuery surface;
+  **fn:sum((), $zero) returns a non-numeric zero verbatim**
+  (sum((), xs:dayTimeDuration("PT0S")) = PT0S); **fn:avg over
+  dayTimeDurations** divides the total seconds and formats
+  (fn-avg-4: PT5H30M); and the kept lexical zero in fn:sum is freed
+  on every result path (a Linux ASAN catch — macOS has no leak
+  sanitizer). (PR #1522)
+
+
+
+## [1.9.300] - 2026-10-04
+
+### Added
+
+- **XQuery: the xs:float and int64 typed-atom channels survive the
+  numeric function hop (+49 QT3 agreements; the fifteen-family batch
+  pins rise 1078→1127 and fn:round is fully green at 220/220)**.
+  fn:abs, fn:round, fn:round-half-to-even and the avg/min/max
+  aggregates copy the float tag onto their results (round over
+  xs:float("3.4028235E38") spells 3.4028235E38, not the widened
+  double digits); fn:sum keeps an exact long-long total when every
+  member is an integer lexical (fn:sum#2's zero seeds it); fn:floor,
+  fn:ceiling, fn:round and fn:abs pass int64 atoms through unchanged
+  (floor(xs:integer("999999999999999999")) stays exact, not 1e18).
+  (PR #1520)
+
+- **xs:byte, xs:unsignedByte and xs:unsignedInt constructors** —
+  the three integer subtypes were unregistered and errored as
+  unknown functions. (PR #1520)
+
+### Fixed
+
+- **is_int results now also carry the double field** — eq and
+  boolean() comparisons read number_value, which the int64 path
+  left unset (sum((3,4,5)) eq 12 was false). (PR #1520)
+
+- **The float-precision speller snaps into the float domain before
+  spelling** — double arithmetic can leave a non-float-representable
+  value whose shortest float round-trip never terminates, spelling
+  18-digit mantissas. (PR #1520)
+
+
+
+## [1.9.299] - 2026-10-04
+
+### Added
+
+- **XQuery: 1078 QT3 cases adopted across fifteen fn families** —
+  the numeric aggregates and rounding set (abs, avg, ceiling, floor,
+  max, min, round, round-half-to-even, sum) plus the higher-order
+  combiners (apply, filter, for-each, for-each-pair, fold-left,
+  fold-right), vendored verbatim from the upstream QT3 mirror. The
+  named per-suite excludes document the typed-atom lane's remaining
+  levers (xs:float spelling through aggregates, int64-exact
+  multi-argument sums, instance-of results). (PR #1518)
+
+- **fn:sum#2** — the zero argument returns its value for the empty
+  sequence: fn:sum((1,2,3), 10) = 16, fn:sum((), 5) = 5.
+  (PR #1518)
+
+### Fixed
+
+- **Number spelling destroyed integral magnitudes** — the shared
+  trailing-zero trim ran on dot-free integer renderings, so 1e18
+  spelled "1"; it now runs only when a decimal point is present.
+  Negative zero also spells "-0" (fn:round(-0.01) = -0), and
+  fn:round preserves -0 for inputs in (-0.5, 0). (PR #1518)
+
+- **Value carriers overflowed at DBL_MAX** — the ext31 string
+  carrier used the libxml2-parity printer, which renders DBL_MAX
+  with 18 significant digits; strtod read-back of that string
+  overflows to infinity, so fn:avg((1.7976931348623157E308)) was
+  INF. Carriers now use the injective shortest-round-trip spelling.
+  (PR #1518)
+
+- **fn:sum rejected non-nodeset arguments** — single-item sequences
+  (passed as scalars by the XQuery adapter) errored out. (PR #1518)
+
+- **fn:round()/fn:round-half-to-even(()) now return the empty
+  sequence** under the XQuery surface; XPath 1.0 coercion stays NaN
+  (libxml2 parity unchanged). (PR #1518)
+
+- **fn:max/fn:min over non-numeric items** (xs:string, xs:anyURI)
+  compare in codepoint order and return the extreme item instead of
+  coercing to zero. (PR #1518)
+
+- **QT3 runner: the standard `emptydoc`/`empty` environments
+  resolve to the empty context** — cases carrying them were
+  silently skipped (the abs/ceiling/floor/fold-* families adopted
+  zero cases before this). (PR #1518)
+
+
+
+## [1.9.298] - 2026-10-04
+
+### Added
+
+- **XPath/XQuery: the six remaining string functions honor UCA
+  collations (DUCET lane closed)** — starts-with, ends-with,
+  contains, substring-before, substring-after and deep-equal now
+  route `http://www.w3.org/2013/collation/UCA` URIs through the
+  collation module. Matching scans codepoint-aligned windows under
+  the collation compare (every collation-unit boundary falls
+  between codepoints, so the scan is exact across contractions and
+  normalization); substring-before/after slice the leftmost-shortest
+  occurrence. deep-equal threads the collation into plain string
+  atoms and map values, while \x03-marked carriers keep their
+  value-space equality. **QT3 adoption rises by 73 cases**:
+  contains 46→63, starts-with 43→56, ends-with 34→48,
+  substring-before 12→26, substring-after 16→29, deep-equal
+  221→223. (PR #1515)
+
+- **Collation: UCA 7.1.1 implicit weights** — codepoints with no
+  DUCET mapping sort by the two-CE algorithm: the registered
+  @implicitweights ranges (Tangut/Tangut-Supplement base FB00,
+  Khitan FB02, Nushu FB01) order ahead of the unassigned groups
+  (base 0xFB80 + 2*(cp>>15)), each codepoint emitting an
+  even/odd CE pair that orders within its group by codepoint.
+  (PR #1515)
+
+- **Collation: `alternate=blanked`** (fn-contains-35..38) — the
+  third W3C UCA variable-weighting value is accepted, and variable
+  collation elements now leave every ordinary level under
+  shifted/blanked weighting (shifted retains its quaternary
+  re-add; blanked drops them wholly — ICU variable semantics).
+  (PR #1515)
+
+- **CLI: `leptris xslt` command** — apply a stylesheet to a
+  document and print the serialized result tree:
+  `leptris xslt -s style.xsl input.xml`. Conventions match
+  xsltproc: INPUT is a file path, `-` or absent reads stdin. The
+  stylesheet compiles via leptris_xslt_parse_file, so
+  xsl:include/xsl:import resolve relative to the sheet. New
+  CLI_ERROR_XSLT exit code (7). (PR #1516)
+
+- **CLI: man pages for every command** — new leptris-xslt.1 plus
+  the missing leptris-xquery.1, leptris-diff.1 and
+  leptris-validate.1, all registered for generation. (PR #1516)
+
+### Fixed
+
+- **CLI: `--help` was missing registered commands** — the usage
+  text hand-maintained its own command list, so the registered
+  `diff` and `xquery` commands were invisible. The help listing
+  now iterates the command registry (the descriptors are the
+  single source of truth), and adding a command can no longer
+  leave help stale. xquery's private stream reader is promoted to
+  shared cli_read_stream/cli_read_file. (PR #1516)
+
+
+
+## [1.9.297] - 2026-10-03
+
+### Fixed
+
+- **XQuery: string lt/gt are codepoint value comparisons** — the
+  shared XPath 1.0 comparison numeric-coerced strings, so two
+  collation-keys that both spell numbers compared as equal numbers.
+  Both comparison sites now codepoint-compare string operands when
+  the evaluation is XQuery-flavored (the evaluator's string branch
+  and the VM twin); XPath 1.0 evaluation is unchanged.
+  (PR #1513)
+
+- **XQuery: fn:codepoints-to-string encodes every item of its
+  sequence argument** — the collector collapsed a parenthesized
+  sequence to one scalar (its space-joined spelling), so
+  (37, 65500, 37) encoded as just the first codepoint. Collation-key
+  adoption rises to 12/56 run-and-agree. (PR #1513)
+
+
+
+## [1.9.296] - 2026-10-03
+
+### Added
+
+- **XPath/XQuery: 71 QT3 collation cases adopted (DUCET slice 4)** —
+  the misc/UCACollation corpus (62 cases: the UCA ordering battery
+  over DUCET weights) and fn/collation-key (9 cases). The collation
+  URI grammar now parses the W3C semicolon-separated parameter form,
+  accepts lang= (DUCET is the root locale), and applies
+  caseFirst=upper|lower by swapping the DUCET case tertiaries.
+  fn:collation-key gains its 1-argument form (the static default
+  collation; codepoint keys are the UTF-8 bytes) and its keys are
+  lowercase hex — injective AND order-preserving, so lt/gt on two
+  keys is byte-wise key order. The QT3 runner now credits an
+  error alternative inside any-of for a failed evaluation, gates the
+  optional simple-uca-fallback feature (this engine raises FOCH0002
+  per the strict F&O reading), and lifts the pre-DUCET
+  collation/UCA exclusion under a DUCET build. (PR #1511)
+
+### Fixed
+
+- the DUCET implicit-weight fallback dropped a mask that broke
+  ordering between high codepoints. (PR #1511)
+
+
+
+## [1.9.295] - 2026-10-03
+
+### Added
+
+- **XPath: collation-aware functions over the vendored DUCET
+  (slices 2-3)** — fn:compare's 3-argument form honors its collation
+  URI (unknown needed collations raise FOCH0002; unknown-but-unneeded
+  ones are ignored per the QT3 any-of expectations);
+  fn:collation-key($key, $collation) is new, returning the UCA sort
+  key as base64 text (the result-type enum is ABI-frozen with no
+  binary kind; base64 is injective, so key equality is byte equality);
+  fn:index-of, fn:distinct-values and fn:sort route plain-string
+  comparisons through the collation while typed atoms keep their
+  value-space equality. DUCET-gated: builds without utf8proc keep the
+  previous behavior. (PRs #1508, #1509)
+
+
+
+## [1.9.294] - 2026-10-03
+
+### Added
+
+- **XPath: UCA collation over the vendored DUCET table (slice 1)** —
+  `http://www.w3.org/2013/collation/UCA` collation URIs parse
+  `strength` and `alternate` parameters per F&O 3.x (defaults:
+  tertiary, non-ignorable) and compare through multi-level sort keys:
+  NFD (utf8proc) → DUCET weights (Unicode 16.0.0, 38,443 single
+  codepoints + 964 contractions, vendored with an offline table
+  generator) → primary/secondary/tertiary levels with 0x00
+  separators; `alternate=shifted` demotes variable primaries to the
+  quaternary level. Codepoint and html-ascii-case-insensitive
+  collations keep their semantics. Unmapped codepoints get a coarse
+  deterministic fallback (the full UCA 7.1.1 implicit-weight
+  algorithm is a later slice). New CMake option
+  `LEPTRIS_ENABLE_DUCET` (default on, requires utf8proc; builds
+  without utf8proc degrade to codepoint collation). Function
+  wiring (fn:compare, fn:collation-key, default collation) and
+  QT3 UCA case adoption are the next slices. (PR #1506)
+
+- **XQuery: fn:normalize-unicode F&O conformance** — the
+  single-argument form normalizes with NFC instead of returning the
+  input unchanged; unknown normalization forms raise FOCH0003
+  instead of silently falling back to NFC; the form argument is
+  case-insensitive with surrounding whitespace tolerated
+  (FULLY-NORMALIZED is gone from F&O 3.x; its satisfied="false"
+  twins run). utf8proc-gated end to end; the 29-run
+  fn/normalize-unicode QT3 family is adopted. (PR #1505)
+
+### Fixed
+
+- DUCET builds without utf8proc (cppcheck leg, Rust lane, ILP32,
+  Windows static) degrade to codepoint collation with a warning
+  instead of failing the configure. (PR #1506)
+
+
+
+## [1.9.293] - 2026-10-03
+
+### Performance
+
+- DOM: per-thread recycle of mutation blocks. Document create/build/free
+  cycles now park their elem (45KB), name (4KB) and attr (5KB) blocks on
+  thread-local free-lists instead of returning them to malloc — the next
+  cycle carves from hot pages instead of re-faulting fresh ones. Byte-capped
+  (8MB elem, 4MB name/attr); POSIX threads drain via a pthread_key
+  destructor at thread exit, and `leptris_explicit_cleanup()` drains
+  synchronously. Mutation doc-cycle row: 19.4 → 15.1 ns/child (−22%), gap
+  to pugixml on that shape narrows 1.66x → 1.29x. Single-document append
+  throughput is unchanged. (PR #1503)
+
+### Rust bindings
+
+- First fully tokenless crates.io release: leptris v1.4.1 published from CI
+  via crates.io Trusted Publishing (`rust-lang/crates-io-auth-action` —
+  cargo itself has no native OIDC support). The Rust release lane now needs
+  no registry token of any kind. (PRs #1497, #1499–#1502)
+
+## [1.9.292] - 2026-10-02
+
+### Added
+
+- **DOM: `set_root` adopts foreign roots (leptris-ruby #371)** — an element
+  owned by another document is no longer rejected with EINVAL. Nodes are
+  pool-owned by their document, so adoption deep-copies the subtree into the
+  target document's pool (all node kinds, attributes, and namespace
+  declarations survive); the source document loses the element (root pointers
+  cleared, element spliced out of its document-child chain — Nokogiri steal
+  observability), and the detached original stays resolvable in its own pool
+  until the source document is freed. The new
+  `leptris_document_set_root_ex(doc, root, &installed)` reports the installed
+  element — a fresh handle distinct from the source pointer — so bindings wrap
+  the right node; the legacy entry keeps its signature and adopts too.
+  Parent-attached elements still reject EINVAL, and same-document installs
+  are unchanged.
+
+
+
+## [1.9.291] - 2026-10-02
+
+### Fixed
+
+- **DOM: removed nodes leave clean orphans** — `leptris_element_remove_child`
+  unlinked the child from the parent's list but left the child's own
+  `next_sibling` intact, so a later append spliced the stale sibling run into
+  the new parent — nodes reachable from two parents, up to self-containing
+  cycles that never terminate in serialization. `leptris_element_remove_all_children`
+  had the same defect through its parent-backpointer walk. Both now clear the
+  removed nodes' own sibling links, matching `leptris_node_unlink` and libxml2
+  `xmlUnlinkNode` semantics (leptris-ruby#370).
+- **XPath: `prefix:*` is namespace-scoped** — three bytecode fusion sites in
+  the compiler classified a prefixed wildcard as a plain wildcard and lowered
+  `.//m:*` and `/descendant-or-self::m:*` to the any-element fast opcodes,
+  ignoring the caller's namespace bindings entirely: a bound `m:*` matched
+  every element (no-namespace ones included), and the unbound literal-prefix
+  fallback never ran. Prefixed wildcards now stay on the generic step path,
+  whose matcher resolves the test prefix through the evaluation context's
+  bindings — URI equality across prefixes, literal-prefix comparison when
+  unbound (leptris-ruby#368).
+
+### Added
+
+- **Plan API: struct-size accessors for binding skew detection** —
+  `leptris_plan_spec_struct_size`, `leptris_plan_{element,child,attr,predicate}_row_size`
+  return the engine's compiled row layouts so bindings can verify them against
+  the headers they compiled with and fail loudly on version skew instead of
+  misparsing rows. Root cause behind #1490 (the engine's nested `ns_form`
+  semantics were correct; the consumer straddled an older engine with newer
+  headers). A nested-child regression spec now pins all three `ns_form`
+  behaviors, including that a non-matching URI keeps the child element.
+
+
+
 ## [1.9.290] - 2026-10-02
 
 <!-- Edit this section with the actual release notes. -->