leptris 1.9.308.0 → 1.9.309.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef02878e818136f9074d6bdeeb54a55db40d0d6287974a96c81979afe7ed525
-  data.tar.gz: 23468d7fdb2db0aae806d90c0d4d312a9190fe2c69f28333ef202a125c504675
+  metadata.gz: 3cc7498cffb29da21d5b13691fd7ac8de3b4abdf89765699ecf79d03b186c1e1
+  data.tar.gz: 897683cbf8a8b510f733e51e3990e508d3d72ef45b1ef47985d8c601aecc68ff
 SHA512:
-  metadata.gz: 25aa1f2055a658fbbafdf9031d765311c6a83de1bdbc61d4535a755ae103315e49c4cd99531faa5db5389c2c889175dde051747c86411e278999083c442d161f
-  data.tar.gz: 1a5b9875f8fb26486d82e19ad6f70d0a76ce8cb5128e2b7e1fffa5f6c3ac284085199e067e6dc97aa6d2ecbc67909df490d055dd8728b55bf4e8e4179d4073b3
+  metadata.gz: 481e075161468c9de96a2e6cdb66cb904b003f007aeb53188e5ad1919b059265b176c87ddcc944d43d3ef093431733a1d8525630f879d0e102888e02e895d51e
+  data.tar.gz: 0b31da872763118c3bad5f0b6fa1398e758fc6732863dbb27b3f25858eed3f5824073248ebacdd51332ba7fa406a62144933cd9e7cf9cd6e72a36fe8a4411325

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [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

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,40 @@
 ## [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

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/xpath/evaluator.c

@@ -973,6 +973,10 @@ static struct leptris_xpath_result* evaluate_literal(XPathContext* ctx,
             struct leptris_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER);
             if (!result) return NULL;
             result->value.number_value = ast->number_value;
+            /* XQuery literal typing from the lexical (the parser
+             * stashed "xs:decimal"/"xs:double" in value; integers
+             * stay unlabeled). */
+            result->atomic_type = ast->value;
             return result;
         }
 

data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c

@@ -777,6 +777,7 @@ int xpath_result_matches_type(struct leptris_xpath_result* v,
                     ? ((XPathTextNode*)n)->content : NULL;
             int is_num_member = mc && mc[0] == '\x03' &&
                                 (mc[1] == 'N' || mc[1] == 'O' ||
+                                 mc[1] == 'D' ||
                                  (mc[1] == 'F' &&
                                   !((mc[2] == 'N' && mc[3] == '\x02') ||
                                     mc[2] == 'R')));
@@ -809,7 +810,32 @@ int xpath_result_matches_type(struct leptris_xpath_result* v,
     }
     if (is_string_ty) return v->type == XPATH_RESULT_STRING;
     if (is_bool_ty) return v->type == XPATH_RESULT_BOOLEAN;
-    if (is_num_ty) return v->type == XPATH_RESULT_NUMBER;
+    if (is_num_ty) {
+        if (v->type != XPATH_RESULT_NUMBER) return 0;
+        /* A labeled numeric result discriminates its subtype for
+         * typeswitch / instance of (fn-min/max-10). Unlabeled
+         * numbers keep the historical any-numeric match. XDM
+         * derivation: xs:integer matches a xs:decimal test. */
+        if (v->atomic_type &&
+            strncmp(v->atomic_type, "xs:", 3) == 0) {
+            const char* at = v->atomic_type + 3;
+            int at_num =
+                strcmp(at, "integer") == 0 ||
+                strcmp(at, "decimal") == 0 ||
+                strcmp(at, "float") == 0 ||
+                strcmp(at, "double") == 0;
+            int b_num =
+                strcmp(base, "xs:integer") == 0 ||
+                strcmp(base, "xs:decimal") == 0 ||
+                strcmp(base, "xs:float") == 0 ||
+                strcmp(base, "xs:double") == 0;
+            if (at_num && b_num)
+                return strcmp(at, base + 3) == 0 ||
+                       (strcmp(base, "xs:decimal") == 0 &&
+                        strcmp(at, "integer") == 0);
+        }
+        return 1;
+    }
     if (strcmp(base, "item()") == 0) return 1;
     return 0;   /* node kinds: a scalar is not a node */
 }
@@ -2887,6 +2913,7 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                     int is_num_member = mc && mc[0] == '\x03' &&
                                         (mc[1] == 'N' ||
                                          mc[1] == 'O' ||
+                                         mc[1] == 'D' ||
                                          (mc[1] == 'F' &&
                                           !((mc[2] == 'N' &&
                                              mc[3] == '\x02') ||
@@ -2956,6 +2983,28 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 }
                 else if (is_num_ty) {
                     m = v->type == XPATH_RESULT_NUMBER;
+                    /* A labeled numeric result discriminates its
+                     * subtype (K2-ABSFunc/fn-abs-1: abs preserves
+                     * the argument type); unlabeled numbers keep
+                     * the any-numeric match. */
+                    if (m && v->atomic_type &&
+                        strncmp(v->atomic_type, "xs:", 3) == 0) {
+                        const char* at = v->atomic_type + 3;
+                        int at_num =
+                            strcmp(at, "integer") == 0 ||
+                            strcmp(at, "decimal") == 0 ||
+                            strcmp(at, "float") == 0 ||
+                            strcmp(at, "double") == 0;
+                        int b_num =
+                            strcmp(base, "xs:integer") == 0 ||
+                            strcmp(base, "xs:decimal") == 0 ||
+                            strcmp(base, "xs:float") == 0 ||
+                            strcmp(base, "xs:double") == 0;
+                        if (at_num && b_num)
+                            m = strcmp(at, base + 3) == 0 ||
+                                (strcmp(base, "xs:decimal") == 0 &&
+                                 strcmp(at, "integer") == 0);
+                    }
                     if (m && is_int_ty)
                         m = v->is_int ||
                             (v->value.number_value ==

data/vendor-src/libleptris/src/leptris/xpath/functions.c

@@ -2544,9 +2544,20 @@ static struct leptris_xpath_result* xpath_func_floor(XPathContext* context,
 
     struct leptris_xpath_result* arg_result = xpath_evaluate(context, args[0]);
     if (!arg_result) return NULL;
+    /* XQuery surface: floor(()) is the empty sequence
+     * (K-FloorFunc-3); XPath 1.0 coercion gives NaN. */
+    if (context->xquery_spelling &&
+        arg_result->type == XPATH_RESULT_NODESET &&
+        (!arg_result->value.nodeset_value ||
+         xpath_nodeset_count(arg_result->value.nodeset_value) == 0)) {
+        xpath_result_free(arg_result);
+        return xpath_result_new(XPATH_RESULT_NODESET);
+    }
 
     int iv_int = arg_result->is_int;
     long long iv = arg_result->int_value;
+    int fl = xpath_result_is_float(arg_result);
+    int xq = arg_result->xq_spelling;
     double num = result_to_number(arg_result);
     xpath_result_free(arg_result);
 
@@ -2560,7 +2571,14 @@ static struct leptris_xpath_result* xpath_func_floor(XPathContext* context,
         result->int_value = iv;
         return result;
     }
+    if (fl) {
+        result->value.number_value = (double)(float)floor(num);
+        result->atomic_type = "xs:float";
+        result->xq_spelling = xq;
+        return result;
+    }
     result->value.number_value = floor(num);
+    result->xq_spelling = xq;
     return result;
 }
 
@@ -2577,9 +2595,20 @@ static struct leptris_xpath_result* xpath_func_ceiling(XPathContext* context,
 
     struct leptris_xpath_result* arg_result = xpath_evaluate(context, args[0]);
     if (!arg_result) return NULL;
+    /* XQuery surface: ceiling(()) is the empty sequence
+     * (K-CeilingFunc-3); XPath 1.0 coercion gives NaN. */
+    if (context->xquery_spelling &&
+        arg_result->type == XPATH_RESULT_NODESET &&
+        (!arg_result->value.nodeset_value ||
+         xpath_nodeset_count(arg_result->value.nodeset_value) == 0)) {
+        xpath_result_free(arg_result);
+        return xpath_result_new(XPATH_RESULT_NODESET);
+    }
 
     int iv_int = arg_result->is_int;
     long long iv = arg_result->int_value;
+    int fl = xpath_result_is_float(arg_result);
+    int xq = arg_result->xq_spelling;
     double num = result_to_number(arg_result);
     xpath_result_free(arg_result);
 
@@ -2591,7 +2620,16 @@ static struct leptris_xpath_result* xpath_func_ceiling(XPathContext* context,
         result->int_value = iv;
         return result;
     }
+    /* F&O: the result of an xs:float argument is xs:float —
+     * float32-computed and float-spelled (fn-ceilingflt1args). */
+    if (fl) {
+        result->value.number_value = (double)(float)ceil(num);
+        result->atomic_type = "xs:float";
+        result->xq_spelling = xq;
+        return result;
+    }
     result->value.number_value = ceil(num);
+    result->xq_spelling = xq;
     return result;
 }
 

data/vendor-src/libleptris/src/leptris/xpath/functions_ext31.c

@@ -1066,7 +1066,7 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
                     return out;
                 }
             }
-        } else if (!fallthrough && any_flt) {
+        } else if (!fallthrough && any_flt && !any_dbl) {
             /* F&O: when xs:float is the common type, EVERY item
              * converts to xs:float before summing (Saxon computes
              * the float32-converted addends in double, then the
@@ -1096,7 +1096,10 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
         } else if (!fallthrough && any_dbl) {
             /* xs:double in the mix: label the result so typeswitch
              * sees it (cbcl-avg-008); value stays the generic
-             * double accumulation. */
+             * double accumulation. NOTE the guard order above: the
+             * float branch is gated on !any_dbl, so the ladder
+             * checks widest-first — float+double routes HERE, not
+             * to the float path. */
             out->atomic_type = "xs:double";
         }
         free(kinds);
@@ -1149,6 +1152,27 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
      * fn-*-flt1args battery). */
     if (all_float && out->type == XPATH_RESULT_NUMBER)
         out->atomic_type = "xs:float";
+    /* fn:min/max label the result with the promoted input type so
+     * typeswitch / instance of discriminate the numeric subtype
+     * (fn-min/max-10: integer -> decimal -> float -> double as the
+     * prefix grows). Widest-first, same ladder as fn:avg. */
+    if (which >= 2 && kinds && out->type == XPATH_RESULT_NUMBER &&
+        !out->atomic_type) {
+        int a_dbl = 0, a_flt = 0, a_dec = 0, a_int = 1;
+        for (size_t k = 0; k < cnt; k++) {
+            switch (kinds[k]) {
+                case AVG_KIND_INT: break;
+                case AVG_KIND_DBL: a_dbl = 1; a_int = 0; break;
+                case AVG_KIND_FLT: a_flt = 1; a_int = 0; break;
+                case AVG_KIND_DEC: a_dec = 1; a_int = 0; break;
+                default: a_int = 0; break;
+            }
+        }
+        if (a_int) out->atomic_type = "xs:integer";
+        else if (a_dbl) out->atomic_type = "xs:double";
+        else if (a_flt) out->atomic_type = "xs:float";
+        else if (a_dec) out->atomic_type = "xs:decimal";
+    }
     free_items(items, cnt);
     free(kinds);
     return out;
@@ -1198,10 +1222,33 @@ static struct leptris_xpath_result* fn_math1(XPathContext* ctx,
         XPathASTNode** args, size_t n, double (*f)(double)) {
     struct leptris_xpath_result* r = xpath_evaluate(ctx, args[0]);
     if (!r) return NULL;
+    /* ceiling(()) is the empty sequence on the XQuery surface
+     * (K-CeilingFunc-3); XPath 1.0 coercion gives NaN. */
+    if (ctx->xquery_spelling &&
+        r->type == XPATH_RESULT_NODESET &&
+        (!r->value.nodeset_value ||
+         r->value.nodeset_value->count == 0)) {
+        leptris_xpath_result_free(r);
+        return xpath_result_new(XPATH_RESULT_NODESET);
+    }
+    int fl = xpath_result_is_float(r);
+    int xq = r->xq_spelling;
     double d = leptris_xpath_result_number(r);
     leptris_xpath_result_free(r);
     struct leptris_xpath_result* out = xpath_result_new(XPATH_RESULT_NUMBER);
-    if (out && n) out->value.number_value = f(d);
+    if (out && n) {
+        /* F&O: ceiling/floor/round of an xs:float stays xs:float —
+         * compute in float32 and spell at float precision
+         * (fn-ceilingflt1args: the double spelling of the same
+         * value differs). */
+        if (fl) {
+            out->value.number_value = (double)(float)f(d);
+            out->atomic_type = "xs:float";
+        } else {
+            out->value.number_value = f(d);
+        }
+        out->xq_spelling = xq;
+    }
     return out;
 }
 
@@ -1272,20 +1319,61 @@ static struct leptris_xpath_result* fn_abs(XPathContext* ctx,
         return xpath_result_new(XPATH_RESULT_NODESET);
     }
     int fl = xpath_result_is_float(r);
+    int r_dec = r->atomic_type &&
+                strcmp(r->atomic_type, "xs:decimal") == 0;
+    int r_dbl = 0;
+    /* A FOR-bound argument is a single-item NODESET carrying the
+     * typed-scalar MARK (the scalar atomic_type is long gone):
+     * read D/O back off the mark (fn-abs-1). */
+    if (r->type == XPATH_RESULT_NODESET && r->value.nodeset_value &&
+        r->value.nodeset_value->count == 1) {
+        void* nd = r->value.nodeset_value->nodes[0];
+        if ((int)XPATH_NODE_TYPE(nd) == LEPTRIS_NODE_TEXT) {
+            const char* mc = ((XPathTextNode*)nd)->content;
+            if (mc && mc[0] == '\x03') {
+                if (mc[1] == 'D') r_dec = 1;
+                else if (mc[1] == 'O') r_dbl = 1;
+            }
+        }
+    }
+    int xq = r->xq_spelling;
     int iv_int = r->is_int;
     long long iv = r->int_value;
     double d = leptris_xpath_result_number(r);
+    /* A bare-N synthetic (FLWOR-bound plain integer, fn-abs-1's
+     * walk over (1, xs:decimal(2), ...)) loses the is_int bit:
+     * an integer lexical on an UNLABELED number is an integer. */
+    if (!iv_int && !fl && !r_dec && !r->atomic_type && !r_dbl) {
+        char* ps = xpath_number_to_string_xq_typed(d, 0);
+        if (ps && num_int_lexical(ps)) {
+            iv_int = 1;
+            iv = (long long)d;
+        }
+        LEPTRIS_FREE(ps);
+    }
     leptris_xpath_result_free(r);
     struct leptris_xpath_result* out = xpath_result_new(XPATH_RESULT_NUMBER);
     if (out && n) {
+        out->xq_spelling = xq;
         if (iv_int) {
             out->value.number_value = fabs(d);
             out->is_int = 1;
             out->int_value = iv < 0 ? -iv : iv;
         } else {
+            if (fl) d = (double)(float)fabs(d);
             out->value.number_value = fabs(d);
         }
-        if (fl) out->atomic_type = "xs:float";
+        /* F&O: abs preserves the argument type (fn-abs-1 walks
+         * integer/decimal/float/double through instance-of). */
+        if (fl) {
+            out->atomic_type = "xs:float";
+        } else if (r_dec) {
+            out->atomic_type = "xs:decimal";
+        } else if (!iv_int) {
+            /* Unlabeled non-integers are doubles (XQuery literal
+             * typing also routes exponents here). */
+            out->atomic_type = r_dbl ? "xs:double" : "xs:double";
+        }
     }
     return out;
 }
@@ -1305,26 +1393,86 @@ static struct leptris_xpath_result* fn_round_half_even(XPathContext* ctx,
     }
     double v = leptris_xpath_result_number(r);
     int fl = xpath_result_is_float(r);
+    int xq = r->xq_spelling;
     leptris_xpath_result_free(r);
-    int prec = 0;
+    double prec = 0;
     if (n >= 2) {
         struct leptris_xpath_result* p = xpath_evaluate(ctx, args[1]);
-        prec = p ? (int)leptris_xpath_result_number(p) : 0;
+        /* The scale can exceed int range (cbcl-round-half-to-even:
+         * 4294967296) — keep it in double throughout; an (int) cast
+         * is UB past INT_MAX. */
+        prec = p ? leptris_xpath_result_number(p) : 0;
         if (p) leptris_xpath_result_free(p);
     }
-    double scale = pow(10.0, prec);
-    double x = v * scale;
+    if (prec > 0) {
+        /* Positive scale: round(x*10^p)/10^p, ties to even on the
+         * scaled integer via fmod (no long-long truncation). A
+         * scale beyond the double's precision leaves the value
+         * unchanged (pow overflows to INF — cbcl-round-half-to-even
+         * rounds at scale 2^32). */
+        double scale = pow(10.0, prec);
+        if (!(scale < INFINITY)) {
+            struct leptris_xpath_result* out =
+                xpath_result_new(XPATH_RESULT_NUMBER);
+            if (out) {
+                out->value.number_value = v;
+                if (fl) out->atomic_type = "xs:float";
+                out->xq_spelling = xq;
+            }
+            return out;
+        }
+        double x = v * scale;
+        double f = floor(x);
+        double diff = x - f;
+        double rounded;
+        if (diff == 0.5)
+            rounded = (fmod(f, 2.0) == 0) ? f : f + 1;
+        else
+            rounded = floor(x + 0.5);
+        struct leptris_xpath_result* out =
+            xpath_result_new(XPATH_RESULT_NUMBER);
+        if (out) {
+            out->value.number_value = rounded / scale;
+            if (fl) out->atomic_type = "xs:float";
+            out->xq_spelling = xq;
+        }
+        return out;
+    }
+    if (prec < 0) {
+        /* Negative scale: round to a multiple of 10^-prec, ties to
+         * even on the quotient. */
+        double scale = pow(10.0, -prec);
+        double x = v / scale;
+        double f = floor(x);
+        double diff = x - f;
+        double rounded;
+        if (diff == 0.5)
+            rounded = (fmod(f, 2.0) == 0) ? f : f + 1;
+        else
+            rounded = floor(x + 0.5);
+        struct leptris_xpath_result* out =
+            xpath_result_new(XPATH_RESULT_NUMBER);
+        if (out) {
+            out->value.number_value = rounded * scale;
+            if (fl) out->atomic_type = "xs:float";
+            out->xq_spelling = xq;
+        }
+        return out;
+    }
+    /* prec == 0: plain round-half-to-even. */
+    double x = v;
     double f = floor(x);
     double diff = x - f;
     double rounded;
     if (diff == 0.5)
-        rounded = (((long)f) % 2 == 0) ? f : f + 1;   /* tie -> even */
+        rounded = (fmod(f, 2.0) == 0) ? f : f + 1;   /* tie -> even */
     else
         rounded = floor(x + 0.5);
     struct leptris_xpath_result* out = xpath_result_new(XPATH_RESULT_NUMBER);
     if (out) {
-        out->value.number_value = rounded / scale;
+        out->value.number_value = rounded;
         if (fl) out->atomic_type = "xs:float";
+        out->xq_spelling = xq;
     }
     return out;
 }

data/vendor-src/libleptris/src/leptris/xpath/lexer.c

@@ -546,6 +546,15 @@ parse_number:
             if (isdigit((unsigned char)*probe)) {
                 lexer->pos++;
                 lexer->column++;
+                /* The SIGN is part of the literal (1E+1, 5.2E-3):
+                 * without consuming it the token truncates at 'E'
+                 * and the parser reads "1E + 1" as arithmetic
+                 * (1E+1 == 2). */
+                if (lexer->pos < lexer->end &&
+                    (*lexer->pos == '+' || *lexer->pos == '-')) {
+                    lexer->pos++;
+                    lexer->column++;
+                }
                 while (lexer->pos < lexer->end &&
                        isdigit((unsigned char)*lexer->pos)) {
                     lexer->pos++;

data/vendor-src/libleptris/src/leptris/xpath/parser.c

@@ -2815,6 +2815,16 @@ static XPathASTNode* parse_primary_expr(XPathParser* parser) {
         char* num_str = token_to_string(tok);
         if (num_str) {
             node->number_value = strtod(num_str, NULL);
+            /* XQuery literal typing (2.5.1): a '.' (no exponent) is
+             * xs:decimal, an exponent is xs:double, else
+             * xs:integer. The evaluator labels the result from
+             * this lexical kind (value is unused for NUMBER
+             * nodes); integers stay NULL so the hot path stays
+             * allocation-free. */
+            if (strchr(num_str, 'e') || strchr(num_str, 'E'))
+                node->value = leptris_strdup("xs:double");
+            else if (strchr(num_str, '.'))
+                node->value = leptris_strdup("xs:decimal");
             LEPTRIS_FREE(num_str);
         }
         advance_token(parser);

data/vendor-src/libleptris/src/leptris/xquery/xquery.c

@@ -2013,7 +2013,22 @@ static int xq_bind(XPathContext* ctx, const char* name,
                 char* marked = (char*)malloc(sl + 3);
                 if (marked) {
                     marked[0] = '\x03';
-                    marked[1] = 'N';
+                    /* Preserve the typed-scalar label through the
+                     * binding (same vocabulary as the sequence
+                     * fold): fn:min/max over `let $x := (...)`
+                     * classifies its items from these marks — a
+                     * bare 'N' demotes xs:double-spelled-"2" to
+                     * integer (fn-min/max-10). */
+                    marked[1] =
+                        (v->atomic_type &&
+                         strcmp(v->atomic_type, "xs:float") == 0)
+                            ? 'F'
+                        : (v->atomic_type &&
+                           strcmp(v->atomic_type, "xs:decimal") == 0)
+                            ? 'D'
+                        : (v->atomic_type &&
+                           strcmp(v->atomic_type, "xs:double") == 0)
+                            ? 'O' : 'N';
                     if (sl) memcpy(marked + 2, s, sl);
                     marked[2 + sl] = 0;
                     XPathTextNode* tn =

data/vendor-src/libleptris/test/xquery/test_qt3.cpp

@@ -704,6 +704,10 @@ void run_test_set(const char* set_path,
     leptris_document_free(ts);
 }
 
+TEST(Qt3Subset, FnStringToCodepoints) {
+    run_test_set("fn/string-to-codepoints.xml", {}, 28);
+}
+
 TEST(Qt3Subset, FnSubstring) {
     run_test_set("fn/substring.xml",
                  {{"concepts", "fn/substring/concepts.xml"}},
@@ -941,45 +945,30 @@ TEST(Qt3Subset, FnCount) {
  * assertions, mixed-type aggregates, HOF zero-arity apply) —
  * see the batch notes in #1182. */
 TEST(Qt3Subset, FnAbs) {
-    run_test_set("fn/abs.xml", {}, 38, {},
-                 {"K2-ABSFunc-27",
-                 "K2-ABSFunc-28",
-                 "K2-ABSFunc-29",
-                 "K2-ABSFunc-30",
-                 "fn-abs-1"});
+    run_test_set("fn/abs.xml", {}, 43, {},
+                 {});
 }
 TEST(Qt3Subset, FnAvg) {
     run_test_set("fn/avg.xml", {}, 182, {}, {});
 }
 TEST(Qt3Subset, FnCeiling) {
-    run_test_set("fn/ceiling.xml", {}, 39, {},
-                 {"K-CeilingFunc-3",
-                 "fn-ceilingflt1args-1",
-                 "fn-ceilingflt1args-3"});
+    run_test_set("fn/ceiling.xml", {}, 42, {},
+                 {});
 }
 TEST(Qt3Subset, FnFloor) {
-    run_test_set("fn/floor.xml", {}, 39, {},
-                 {"K-FloorFunc-3",
-                 "fn-floorflt1args-1",
-                 "fn-floorflt1args-3"});
+    run_test_set("fn/floor.xml", {}, 42, {},
+                 {});
 }
 TEST(Qt3Subset, FnMax) {
-    run_test_set("fn/max.xml", {}, 176, {},
-                 {"fn-max-10"});
+    run_test_set("fn/max.xml", {}, 177, {}, {});
 }
 TEST(Qt3Subset, FnMin) {
-    run_test_set("fn/min.xml", {}, 175, {},
-                 {"fn-min-10"});
+    run_test_set("fn/min.xml", {}, 176, {}, {});
 }
 TEST(Qt3Subset, FnRound) { run_test_set("fn/round.xml", {}, 220); }
 TEST(Qt3Subset, FnRoundHalfToEven) {
-    run_test_set("fn/round-half-to-even.xml", {}, 76, {},
-                 {"K2-RoundEvenFunc-6",
-                 "K2-RoundEvenFunc-7",
-                 "cbcl-round-half-to-even-001",
-                 "cbcl-round-half-to-even-010",
-                 "cbcl-round-half-to-even-011",
-                 "cbcl-round-half-to-even-012"});
+    run_test_set("fn/round-half-to-even.xml", {}, 82, {},
+                 {});
 }
 TEST(Qt3Subset, FnSum) {
     run_test_set("fn/sum.xml", {}, 210, {}, {});
@@ -989,35 +978,52 @@ TEST(Qt3Subset, FnApply) {
 }
 TEST(Qt3Subset, FnFilter) { run_test_set("fn/filter.xml", {}, 1); }
 TEST(Qt3Subset, FnForEach) {
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/for-each.xml", {}, 0, {},
                  {"for-each-010"});
 }
 TEST(Qt3Subset, FnForEachPair) {
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/for-each-pair.xml", {}, 3, {},
                  {"fn-for-each-pair-024",
                  "fn-for-each-pair-026",
                  "fn-for-each-pair-027"});
 }
 TEST(Qt3Subset, FnFoldLeft) {
+    /* fold-left-016 re-pinned: it folds over a MAP and agrees only
+     * when the entry iteration order is favorable — nondeterministic
+     * across runs (the map-order lever). Re-adopt when the fold
+     * orders entries deterministically. */
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/fold-left.xml", {}, 7, {},
-                 {"fold-left-009",
-                 "fold-left-016",
-                 "fold-left-019",
-                 "fold-left-020",
-                 "fold-left-021",
-                 "fold-left-101",
-                 "fold-left-102",
-                 "fold-left-103",
+                 {"fold-left-009", "fold-left-016",
+                 "fold-left-019", "fold-left-020",
+                 "fold-left-021", "fold-left-101",
+                 "fold-left-102", "fold-left-103",
                  "fold-left-104"});
 }
 TEST(Qt3Subset, FnFoldRight) {
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/fold-right.xml", {}, 9, {},
-                 {"fold-right-013",
-                 "fold-right-020",
-                 "fold-right-101",
-                 "fold-right-102",
-                 "fold-right-103",
-                 "fold-right-104"});
+                 {"fold-right-013", "fold-right-020",
+                 "fold-right-101", "fold-right-102",
+                 "fold-right-103", "fold-right-104"});
 }
 
 /* The regex trio (matches/replace/tokenize/analyze-string) compiles
@@ -1233,16 +1239,12 @@ TEST(Qt3Subset, FnStringJoin) {
 
 TEST(Qt3Subset, FnIndexOf) {
     run_test_set("fn/index-of.xml", {}, 44, {},
-                 {
-                 });
+                 {});
 }
 
 TEST(Qt3Subset, FnInsertBefore) {
-    run_test_set("fn/insert-before.xml", {}, 18, {},
-                 {
-                   "K-SeqInsertBeforeFunc-16", /* lazy error() semantics */
-
-                 });
+    run_test_set("fn/insert-before.xml", {}, 19, {},
+                 {});
 }
 
 TEST(Qt3Subset, FnRemove) {
@@ -1250,11 +1252,13 @@ TEST(Qt3Subset, FnRemove) {
 }
 
 TEST(Qt3Subset, FnReverse) {
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/reverse.xml", {}, 60, {},
-                 {
-                   "K2-SeqReverseFunc-1", /* assert-xml over direct ctors */
-
-                 });
+                 {"K2-SeqReverseFunc-1"});
 }
 
 TEST(Qt3Subset, FnSubsequence) {
@@ -1286,12 +1290,14 @@ TEST(Qt3Subset, FnDistinctValues) {
      * evaluate_predicate_for_node AND the single-item base path in
      * the XPATH_AST_PREDICATE handler — xs:dayTimeDuration("PT0S")[$p]
      * takes the latter). */
+    /* Re-pinned pending the HOF node-carrier lever: fold/for-each
+     * callbacks receive node arguments as synthesized strings, so
+     * node-identity shapes (intersect, union, deep-equal on
+     * elements) disagree. Re-adopt when the HOF call paths carry
+     * nodes by reference. */
     run_test_set("fn/distinct-values.xml", {}, 99, {},
-                 {
-                   "cbcl-distinct-values-002",
-                   "cbcl-distinct-values-002b",
-
-                 });
+                 {"cbcl-distinct-values-002",
+                 "cbcl-distinct-values-002b"});
 }
 
 TEST(Qt3Subset, FnDeepEqual) {

data/vendor-src/libleptris/test/xquery/test_xquery.cpp

@@ -215,7 +215,11 @@ TEST(XQueryCore, InstanceOfIntegerRequiresIntegrality) {
     EXPECT_EQ(seq_string(doc, "fn:abs(1.1) instance of xs:integer"), "false");
     EXPECT_EQ(seq_string(doc, "fn:abs(-3) instance of xs:integer"), "true");
     EXPECT_EQ(seq_string(doc, "xs:byte(4) instance of xs:integer"), "true");
-    EXPECT_EQ(seq_string(doc, "1.1 instance of xs:double"), "true");
+    /* XQuery literal typing (3.13.1): a '.' literal is xs:decimal
+     * (K2-ABSFunc-31: fn:abs(1.1) instance of xs:decimal) — NOT
+     * xs:double. */
+    EXPECT_EQ(seq_string(doc, "1.1 instance of xs:double"), "false");
+    EXPECT_EQ(seq_string(doc, "1.1e0 instance of xs:double"), "true");
     EXPECT_EQ(seq_string(doc, "1.5 instance of xs:decimal"), "true");
     leptris_document_free(doc);
 }

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.308",
+  "version": "1.9.309",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.308.0
+  version: 1.9.309.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi