leptris 1.9.307.0 → 1.9.309.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e764f89b28a825bc247e1d9ee4acaca9509c2d85ca76bb4ab1536c95b2b6367c
-  data.tar.gz: f5d982d19eba0753368eb607beee093babf6163bfef26b109327842ec096f5d2
+  metadata.gz: 3cc7498cffb29da21d5b13691fd7ac8de3b4abdf89765699ecf79d03b186c1e1
+  data.tar.gz: 897683cbf8a8b510f733e51e3990e508d3d72ef45b1ef47985d8c601aecc68ff
 SHA512:
-  metadata.gz: a11a89a2b41b0a9c630308e7f9e9c5bd390ed8b6d6683c2b5a324b6f9aa9d7c726b868ea20ad27260e2b3a78a91aa51046de882fac0099580631718f899d8795
-  data.tar.gz: 1cfc39514919c05a95dee4940da80e94ca24a5bed352e4663101c904649de3a1452686ac74461555eac18017dfdce6b408fad2b0bc8eb6a2287f7c81d5a39f8e
+  metadata.gz: 481e075161468c9de96a2e6cdb66cb904b003f007aeb53188e5ad1919b059265b176c87ddcc944d43d3ef093431733a1d8525630f879d0e102888e02e895d51e
+  data.tar.gz: 0b31da872763118c3bad5f0b6fa1398e758fc6732863dbb27b3f25858eed3f5824073248ebacdd51332ba7fa406a62144933cd9e7cf9cd6e72a36fe8a4411325

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## [1.9.308.0] - 2026-10-05
+
+### Engine sync (libleptris 1.9.308)
+
+- **QT3 #1182 tail (leptris#1540)** — the 13 lever cases:
+  fn:avg's numeric promotion ladder with int64-exact decimal
+  division, the O(xs:double) carrier mark, typeswitch case `$v as
+  TYPE` binding arms, fn:apply function conversion (zero-arity,
+  atomization, sequence members), and fn:sum's per-type canonical
+  duration zero. Full QT3 61/61.
+- **Per-engine crates, step 1 (leptris#1541)** — the shared
+  leptris-descriptor ABI crate in a new Cargo workspace, with the
+  runtime layout gate (Rust size_of vs engine introspection +
+  build/walk round trip) and the build.rs stale-link cache fix.
+  Ruby-side impact: none (Rust-side surface; zero header deltas,
+  audit unchanged 369/368, suite 866/0).
+
+## [1.9.307.0] - 2026-10-05
+
+### Fixed
+
+- **Cross-document LEAF adoption (libleptris 1.9.307, engine
+  #1534 — completing the #1528 fix)**: the #1528 adoption gate
+  covered ELEMENT splice arguments only — a TEXT/CDATA/COMMENT/PI
+  node from another document was still spliced raw, so appending
+  scratch-document leaves (the `add_child(String)` fragment path's
+  text children) and freeing the scratch left the tree pointing
+  into freed memory. The four splice seams now adopt non-element
+  arguments by copy too; same-document moves stay zero-copy.
+  Leaf-adoption specs pin the free-then-walk shape.
+
 ## 1.9.306.0 — 2026-10-05
 
 Rides libleptris v1.9.306 (pin 1.9.304 -> 1.9.306): the Lane 18

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.307"
+LIBLEPTRIS_VERSION = "1.9.309"
 # 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.307.0"
+  VERSION = "1.9.309.0"
 end

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.307
+- libleptris v1.9.309
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,95 @@
 ## [Unreleased]
 
+## [1.9.309] - 2026-10-05
+
+### Fixed
+
+- **XPath lexer: signed exponent literals truncated at the `E` —
+  `1E+1` evaluated to `2` and `3.567812E+3 eq 3567.812` was false.**
+  The number scanner consumed the exponent digits but not its sign,
+  so `1E+1` tokenized as `1E` followed by `+ 1`. The sign is now part
+  of the literal (also `5.2E-3` and friends).
+
+### Added
+
+- **XQuery numeric literal typing (XQuery 3.1 §3.13.1) with
+  end-to-end type discrimination — 17 more QT3 cases adopted
+  (abs +5, ceiling +3, floor +3, round-half-to-even +6), 32 with the
+  same-batch string-to-codepoints and min/max gates.**
+  - Exponent literals are `xs:double`, decimals with a point are
+    `xs:decimal`, plain integers `xs:integer`; `1.1 instance of
+    xs:double` is now `false` per spec.
+  - `instance of` / `typeswitch` match labeled numeric results by
+    XDM derivation (`xs:integer` <: `xs:decimal`); `case $v as TYPE`
+    arms bind their variable inside the arm. Unlabeled numerics keep
+    the historical any-numeric match — no XPath 1.0 surface change.
+  - `fn:abs` preserves its argument's numeric type (integer/decimal/
+    float/double, float through float32); `fn:ceiling`/`fn:floor`
+    label float results; `fn:round-half-to-even` computes its scale
+    in double (no `int` truncation UB at 2^32) and guards huge
+    scales; `fn:min`/`fn:max` label results by promoted input type;
+    FLWOR bindings preserve float/decimal/double marks.
+  - Vendor corpus: `fn/string-to-codepoints.xml` (+28), `fn/min`
+    and `fn/max` +1 each.
+- Remaining pinned QT3 reds are documented by lever in the test
+  harness (HOF node-carrier, map iteration order, typed grouping).
+
+
+## [1.9.308] - 2026-10-05
+
+### Added
+
+- **XPath: `fn:avg` computes in the widest numeric type present
+  (F&O 15.2), 13 QT3 cases adopted (fn/avg 175→182, fn/sum 209→210,
+  fn/apply 5→10).** Every item converts to the common type before
+  summing: with `xs:float` present (no double) the result is
+  `xs:float` and every addend rounds through float32 — the lexical
+  of `xs:float("-3.4028235E38")` is *not* the float32's value
+  (fn-avg-mix-args-012..015); a new `O` typed-scalar mark
+  distinguishes `xs:double` from the N catch-all so float+double
+  promotes to `xs:double` (cbcl-avg-008); an all-integer sequence
+  sums exactly in int64 and divides by long division, spelling the
+  exact decimal where a double carrier loses digits past 2^53
+  (fn-avgintg2args-2/4: −84503251441487847.5). Untyped atomics
+  classify as double (K-SeqAVGFunc-26).
+
+- **XQuery: `typeswitch` accepts the full `case $v as TYPE` arm
+  form**, binding the variable to the operand inside its arm
+  (entries encode `VAR\x02TYPE`). Previously only the type-only
+  form parsed — the binding form was a parse failure.
+
+- **XQuery: `fn:apply` applies XDM function conversion.** An empty
+  array is a legal zero-arity argument list (`apply(true#0, array
+  {})`); node-valued members atomize to their string value
+  (`apply(lower-case#1, [<a>ABC</a>])` = `abc`, built-ins and
+  user-defined functions); a multi-item member of a literal square
+  array stays a SEQUENCE argument — fn:apply evaluates the member
+  expressions directly and the call paths expand the sub-carrier
+  (`fn-apply-03/07`).
+
+- **Rust: the shared descriptor-ABI crate `leptris-descriptor`
+  (ruby#294 topology step 1).** `bindings/rust` is now a Cargo
+  workspace: the `leptris` crate keeps its name and shape, and the
+  new `no_std` `#[repr(C)]` mirror of the descriptor-plan ABI
+  (descriptor.h) is the one record layout the per-engine crate
+  family targets (leptris XML, yeptris YAML, teptris TOML/JSON).
+  The `link` feature declares the engine FFI; the authoritative
+  layout gate compares Rust `size_of` against the engine's own
+  row-size introspection plus a build/walk round trip. `build.rs`
+  now re-runs on `LEPTRIS_LIB_PATH` changes (the link directives
+  were cached, silently linking a stale library).
+
+### Fixed
+
+- `fn:sum`'s duration zero answers the empty sequence in the
+  TYPE's canonical spelling: `PT0S` for `xs:duration` (fn-sum-8),
+  `P0M` kept for `xs:yearMonthDuration` (fn-sum-5).
+- MSVC link failure from `__builtin_add_overflow` (portable
+  int64 range check), and two LSan leaks in the new avg/apply
+  paths — both caught by CI legs that have no local equivalent.
+
+
+
 ## [1.9.307] - 2026-10-05
 
 ### Fixed
@@ -52,6 +142,16 @@
 - (describe changes here)
 
 
+## [1.9.305] - 2026-10-05
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
 ## [1.9.305] - 2026-10-05
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.307
+    VERSION 1.9.309
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/bindings/rust/Cargo.lock

@@ -5,3 +5,10 @@ version = 4
 [[package]]
 name = "leptris"
 version = "1.4.1"
+dependencies = [
+ "leptris-descriptor",
+]
+
+[[package]]
+name = "leptris-descriptor"
+version = "0.1.0"

data/vendor-src/libleptris/bindings/rust/Cargo.toml

@@ -1,3 +1,6 @@
+[workspace]
+members = ["descriptor"]
+
 [package]
 name = "leptris"
 version = "1.4.1"
@@ -13,3 +16,4 @@ build = "build.rs"
 [dependencies]
 
 [dev-dependencies]
+leptris-descriptor = { path = "descriptor", features = ["link"] }

data/vendor-src/libleptris/bindings/rust/README.md

@@ -59,3 +59,22 @@ Mirrors the Ruby (`leptris-ruby`) and Python (`pyleptris`) bindings:
 a hand-maintained FFI layer (`src/ffi.rs`) mirroring the public
 headers, with safe wrappers above it. The FFI drift gate keeps the
 mirror in sync with the C surface.
+
+## Workspace: the shared descriptor-ABI crate
+
+`bindings/rust` is a Cargo workspace. Besides the `leptris crate
+(unchanged name and shape — links-only, resolved via
+`LEPTRIS_LIB_PATH`), it contains the `descriptor` member, published
+as **`leptris-descriptor`**: the `no_std` `#[repr(C)]` mirror of the
+tree-shaped descriptor-plan ABI (`src/include/leptris/descriptor.h`).
+It is the one record layout the whole engine family targets — the
+per-engine crates (`leptris` XML, `yeptris` YAML, `teptris`
+TOML/JSON — topology decided 2026-10-03, leptris-ruby#294) — so
+hosts build plan rows once for every engine. The `link` feature
+declares the engine FFI for the descriptor surface; enable it on
+exactly one crate in the graph.
+
+The authoritative layout gate is `tests/descriptor_abi.rs` in the
+`leptris` crate: it compares Rust `size_of` against the engine's own
+`leptris_plan_*_struct_size` introspection and walks a plan built
+from the mirrored rows.

data/vendor-src/libleptris/bindings/rust/build.rs

@@ -10,6 +10,10 @@ use std::path::{Path, PathBuf};
 use std::{env, fs};
 
 fn main() {
+    // The lib path changes the emitted link directives; without
+    // this the build script output is cached across LEPTRIS_LIB_PATH
+    // changes and tests link a stale library.
+    println!("cargo:rerun-if-env-changed=LEPTRIS_LIB_PATH");
     // Windows: the DLL is libleptris.dll, so the import library is
     // libleptris.lib — link.exe resolves `-l <name>` as <name>.lib.
     // (TODO.concurrency/05 renamed the DLL from leptris.dll.)

data/vendor-src/libleptris/bindings/rust/descriptor/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "leptris-descriptor"
+version = "0.1.0"
+edition = "2021"
+description = "Shared descriptor-plan ABI for the leptris engine family (leptris, yeptris, teptris) — repr(C) mirrors of the tree-shaped descriptor plan records"
+license = "MIT"
+repository = "https://github.com/leptris/leptris"
+homepage = "https://www.leptris.org"
+
+[features]
+# Declares the engine FFI (extern "C") for the descriptor surface.
+# Enable on exactly one binding crate in the dependency graph —
+# the declarations carry no symbols of their own.
+link = []
+
+[dependencies]

data/vendor-src/libleptris/bindings/rust/descriptor/src/lib.rs

@@ -0,0 +1,214 @@
+//! Shared descriptor-plan ABI for the leptris engine family.
+//!
+//! One crate per engine (`leptris` XML, `yeptris` YAML, `teptris`
+//! TOML/JSON) targets this record layout, so hosts build plan rows
+//! once and every engine's compiled-descriptor walk speaks the same
+//! shape. The types mirror `src/include/leptris/descriptor.h` in the
+//! leptris engine — field order is the ABI; NEVER renumber or
+//! reorder. Additive trailing fields only, guarded by an ABI version
+//! bump.
+//!
+//! Layout is verified at runtime against the engine's own
+//! introspection (`leptris_plan_*_struct_size`) by the linking
+//! binding crate's tests.
+//!
+//! This crate is `no_std`: types and constants only, plus the FFI
+//! declarations behind the `link` feature.
+
+#![no_std]
+#![allow(non_camel_case_types, non_snake_case)]
+
+use core::ffi::c_char;
+
+/// Must equal `leptris_plan_abi_version()` reported by the engine.
+pub const PLAN_ABI_VERSION: u32 = 1;
+
+/// Child / attribute plan kinds. Append-only.
+pub type PlanKind = u8;
+pub const PLAN_KIND_SCALAR: PlanKind = 1;
+pub const PLAN_KIND_COLLECTION: PlanKind = 2;
+pub const PLAN_KIND_NESTED: PlanKind = 3;
+pub const PLAN_KIND_RAW: PlanKind = 4;
+pub const PLAN_KIND_CONTENT: PlanKind = 5;
+pub const PLAN_KIND_CALLBACK: PlanKind = 6;
+
+/// Element plan flags.
+pub const PLAN_FLAG_MIXED_CONTENT: u32 = 0x1;
+pub const PLAN_FLAG_ORDERED: u32 = 0x2;
+pub const PLAN_FLAG_CDATA: u32 = 0x4;
+pub const PLAN_FLAG_NS_LENIENT: u32 = 0x8;
+pub const PLAN_FLAG_EMIT_ORDER_SPINE: u32 = 0x10;
+
+/// Namespace matching form for binding an element or attribute.
+pub type PlanNsForm = u8;
+pub const PLAN_NS_NONE: PlanNsForm = 0;
+pub const PLAN_NS_EXACT: PlanNsForm = 1;
+pub const PLAN_NS_ANY: PlanNsForm = 2;
+
+/// Result node kinds (the value tree a walk returns).
+pub type PlanValueKind = i32;
+pub const PLAN_VALUE_ELEMENT: PlanValueKind = 0;
+pub const PLAN_VALUE_SCALAR: PlanValueKind = 1;
+pub const PLAN_VALUE_COLLECTION: PlanValueKind = 2;
+pub const PLAN_VALUE_RAW: PlanValueKind = 3;
+pub const PLAN_VALUE_CALLBACK: PlanValueKind = 4;
+
+/// Attribute-match row: requires every (name, expected value) pair.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct AttrPredicate {
+    /// XML attribute name as it appears on the wire.
+    pub wire_name: *const c_char,
+    /// String-equal match (non-null); host-owned.
+    pub expected_value: *const c_char,
+}
+
+/// Attribute binding row.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct AttrPlan {
+    /// XML attribute name as it appears on the wire.
+    pub wire_name: *const c_char,
+    /// `PlanKind`: SCALAR | COLLECTION | CALLBACK.
+    pub kind: u8,
+    /// Host-defined; echoed back verbatim.
+    pub type_tag: u8,
+    /// Number of `predicates` rows (0 = historical behavior).
+    pub predicate_count: u16,
+    pub pad_pred: u16,
+    pub predicates: *const AttrPredicate,
+    /// Attribute-level namespace form; `wire_name` is the LOCAL
+    /// name when set. NONE (0) keeps wire-name lookup.
+    pub ns_form: u8,
+    pub pad_ns: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+}
+
+/// Child binding row.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ChildPlan {
+    /// XML element name as it appears on the wire: the prefixed
+    /// form ("w:b") binds that literal prefix+local pair; the bare
+    /// local form ("b") binds by local name and lets `ns_form` do
+    /// the namespace work.
+    pub wire_name: *const c_char,
+    pub kind: u8,
+    pub type_tag: u8,
+    /// NESTED: index into `PlanSpec::plans`; -1 otherwise.
+    pub child_plan_index: i32,
+    /// Rule-level namespace form, consulted at child-match time.
+    pub ns_form: u8,
+    pub pad0: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+    /// Element-side predicates; same semantics as `AttrPredicate`.
+    pub predicate_count: u16,
+    pub pad_pred: u16,
+    pub predicates: *const AttrPredicate,
+}
+
+/// One element plan: the attribute and child rows bound to a name.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ElementPlan {
+    /// Local name this plan binds; matching uses the CHILD row's
+    /// `wire_name`.
+    pub element_name: *const c_char,
+    pub ns_form: u8,
+    pub pad0: u8,
+    /// `PLAN_NS_EXACT` only.
+    pub ns_uri: *const c_char,
+    pub attribute_count: u32,
+    pub child_count: u32,
+    pub attribute_plans: *const AttrPlan,
+    pub child_plans: *const ChildPlan,
+    /// `PLAN_FLAG_*`.
+    pub flags: u16,
+    pub pad1: u16,
+}
+
+/// Top-level plan specification handed to the engine.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PlanSpec {
+    /// Must equal the engine's `leptris_plan_abi_version()`.
+    pub abi_version: u32,
+    /// `plans[0]` is the root plan applied to the walk context.
+    pub plan_count: u32,
+    pub plans: *const ElementPlan,
+}
+
+#[cfg(feature = "link")]
+pub mod ffi {
+    //! Engine FFI for the descriptor surface. Enable this feature on
+    //! exactly one crate in the graph (the binding that links an
+    //! engine).
+
+    use super::PlanSpec;
+    use core::ffi::{c_char, c_void};
+
+    /// Opaque engine document handle (leptris: `LeptrisDocument`).
+    pub type DocumentHandle = *mut c_void;
+    /// Opaque engine element handle (leptris: `LeptrisElement`).
+    pub type ElementHandle = *mut c_void;
+    /// Status out-parameter (leptris: `LeptrisStatus*`).
+    pub type StatusPtr = *mut i32;
+    /// Opaque compiled plan.
+    pub type Plan = *mut c_void;
+    /// Opaque walk result value.
+    pub type PlanResult = *const c_void;
+
+    extern "C" {
+        pub fn leptris_plan_abi_version() -> u32;
+        pub fn leptris_plan_spec_struct_size() -> usize;
+        pub fn leptris_plan_element_row_size() -> usize;
+        pub fn leptris_plan_child_row_size() -> usize;
+        pub fn leptris_plan_attr_row_size() -> usize;
+        pub fn leptris_plan_predicate_row_size() -> usize;
+
+        pub fn leptris_plan_build(spec: *const PlanSpec, status: StatusPtr) -> Plan;
+        pub fn leptris_plan_free(plan: Plan);
+
+        pub fn leptris_plan_walk(
+            doc: DocumentHandle,
+            ctx: ElementHandle,
+            plan: Plan,
+            status: StatusPtr,
+        ) -> PlanResult;
+        pub fn leptris_plan_materialize(
+            source: *const c_char,
+            source_len: usize,
+            plan: Plan,
+            status: StatusPtr,
+        ) -> PlanResult;
+        pub fn leptris_plan_result_free(result: PlanResult);
+
+        pub fn leptris_plan_value_kind(v: PlanResult) -> i32;
+        pub fn leptris_plan_value_name(v: PlanResult) -> *const c_char;
+        pub fn leptris_plan_value_type_tag(v: PlanResult) -> u8;
+        pub fn leptris_plan_value_string(v: PlanResult) -> *const c_char;
+        pub fn leptris_plan_value_length(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_position(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_node_kind(v: PlanResult) -> u8;
+        pub fn leptris_plan_value_order_index(v: PlanResult) -> u32;
+        pub fn leptris_plan_value_count(v: PlanResult) -> usize;
+        pub fn leptris_plan_value_at(v: PlanResult, i: usize) -> PlanResult;
+        pub fn leptris_plan_value_children_snapshot(
+            v: PlanResult,
+            names_blob: *mut c_char,
+            blob_cap: usize,
+            name_offsets: *mut usize,
+            type_tags: *mut u8,
+            child_handles: *mut PlanResult,
+        ) -> usize;
+        pub fn leptris_plan_value_attribute(
+            v: PlanResult,
+            wire_name: *const c_char,
+        ) -> *const c_char;
+        pub fn leptris_plan_value_int(v: PlanResult, out: *mut i64) -> i32;
+        pub fn leptris_plan_value_float(v: PlanResult, out: *mut f64) -> i32;
+        pub fn leptris_plan_value_bool(v: PlanResult, out: *mut i32) -> i32;
+    }
+}

data/vendor-src/libleptris/bindings/rust/descriptor/tests/layout.rs

@@ -0,0 +1,50 @@
+//! Compile-time layout invariants for the descriptor ABI mirror.
+//!
+//! These check the crate's internal consistency (trailing-field
+//! discipline, alignment) — the BINDING crate's integration test
+//! verifies the sizes against the engine's own introspection, which
+//! is the authoritative gate.
+
+use leptris_descriptor::*;
+use std::mem::{align_of, size_of};
+
+#[test]
+fn trailing_field_discipline() {
+    // Trailing additive fields must not change the size when zeroed:
+    // zero-extended aggregate initializers stay valid across ABI
+    // additions. repr(C) + these sizes are the contract.
+    assert_eq!(size_of::<PlanSpec>(), 4 + 4 + size_of::<*const u8>());
+    assert_eq!(align_of::<PlanSpec>(), align_of::<*const u8>());
+}
+
+#[test]
+fn kind_and_flag_constants_match_engine_headers() {
+    assert_eq!(PLAN_ABI_VERSION, 1);
+    assert_eq!(PLAN_KIND_SCALAR, 1);
+    assert_eq!(PLAN_KIND_COLLECTION, 2);
+    assert_eq!(PLAN_KIND_NESTED, 3);
+    assert_eq!(PLAN_KIND_RAW, 4);
+    assert_eq!(PLAN_KIND_CONTENT, 5);
+    assert_eq!(PLAN_KIND_CALLBACK, 6);
+    assert_eq!(PLAN_FLAG_MIXED_CONTENT, 0x1);
+    assert_eq!(PLAN_FLAG_ORDERED, 0x2);
+    assert_eq!(PLAN_FLAG_CDATA, 0x4);
+    assert_eq!(PLAN_FLAG_NS_LENIENT, 0x8);
+    assert_eq!(PLAN_FLAG_EMIT_ORDER_SPINE, 0x10);
+    assert_eq!(PLAN_NS_NONE, 0);
+    assert_eq!(PLAN_NS_EXACT, 1);
+    assert_eq!(PLAN_NS_ANY, 2);
+    assert_eq!(PLAN_VALUE_ELEMENT, 0);
+    assert_eq!(PLAN_VALUE_SCALAR, 1);
+    assert_eq!(PLAN_VALUE_COLLECTION, 2);
+    assert_eq!(PLAN_VALUE_RAW, 3);
+    assert_eq!(PLAN_VALUE_CALLBACK, 4);
+}
+
+#[test]
+fn row_layouts_are_pointer_sized_aligned() {
+    assert_eq!(align_of::<AttrPredicate>(), align_of::<*const u8>());
+    assert_eq!(align_of::<AttrPlan>(), align_of::<*const u8>());
+    assert_eq!(align_of::<ChildPlan>(), align_of::<*const u8>());
+    assert_eq!(align_of::<ElementPlan>(), align_of::<*const u8>());
+}