leptris 1.9.390.2 → 1.9.391.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec92f0e6c7b71b0a72db8e812b67de6799e78b21d733c3de029dea60e433460c
-  data.tar.gz: 9d0c460ecb7b79e3be5ab56d619f030b0acd4c7b0bff68152029b5f39acec8af
+  metadata.gz: be01b6e8aa9f7b7c51f9be514123f2f81578e69fc7b2ad702e7831fc0aeb424d
+  data.tar.gz: 2cbb5d3363d09d83352007193e42216570968760b7639bca21d78b7800aa73e2
 SHA512:
-  metadata.gz: 8ff194f06b122d588af50825b60d44b695fcf670a47e83ad84be5d0992b9eab9445e3a8a40c1df307e6d0a13f3a75836fd637cfc6d2ab79a33cf8f367592702e
-  data.tar.gz: 769c589b00fbb8b21e791dedba03761a1af8527e595115c7821f268b9b7f9588f86d5365d35cfd2caaba222226510fc93727bf93bb3c4d4b596b1a9f5ccc11f9
+  metadata.gz: c1c64ca2f128df857f8bdd76dd0abfdc87194f47f690efb148aa5ab62e9745b95c220a45ad82fb766c0d89b76f0026ed110417723410820abd13627d77696da0
+  data.tar.gz: 377c0b0ae5058d4bf8ba93e78922044fb428eb0f9666ab5fb0d3cea685575765d7b048141d469c8dab1ea478b2e9afd2b8c5780dce3bd85ea0822c101bc3a5f0

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+### Fixed
+
+- Rebuild the native object under the Ruby that performs final packaging.
+  Restoring the job Ruby after the per-minor release loop could reuse the
+  last minor's object and overwrite the job minor's bundle with a different
+  Ruby header ABI. The packaging regression now exercises the same workspace
+  under Ruby 3.4, then 4.0, then 3.3 and checks the actual packaged native/GC paths.
+
 ### Added — 1.9.390.2 (namespace snapshot face)
 
 - **Element#namespace_declarations_snapshot (leptris-ruby#565).**

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.390"
+LIBLEPTRIS_VERSION = "1.9.391"
 # 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
@@ -290,7 +290,9 @@ task :compile do
   elsif %w[ruby truffleruby].include?(RUBY_ENGINE)
     ext_dir = "ext/leptris/native"
     Dir.chdir(ext_dir) do
-      sh "ruby extconf.rb"
+      # Packaging restores the job Ruby after the per-minor release loop.
+      # Rebuild even when native.o is newer: it may use another Ruby's headers.
+      sh RbConfig.ruby, "extconf.rb"
       if RUBY_PLATFORM =~ /darwin/
         # Link the bundle ourselves: mkmf snapshots LIBRUBYARG from
         # RbConfig at require time, so setup-ruby's shared-libruby
@@ -300,18 +302,18 @@ task :compile do
         # Makefile, link with pure -undefined dynamic_lookup (Ruby
         # symbols resolve from the loading interpreter) and a
         # conservative deployment target.
-        sh "make native.o"
+        sh "make -B native.o"
         sh "cc -dynamic -bundle -undefined dynamic_lookup " \
            "-mmacosx-version-min=#{ENV['MACOSX_DEPLOYMENT_TARGET'] || '11.0'} " \
            "-o native.bundle native.o"
       else
         # #207: the darwin contract on Linux too — mkmf's `make`
         # linked libruby.so.3.3 (plus a runner runpath), which
-        # failed to load on 3.4/4.0. Link WITHOUT libruby: one
-        # .so serves every Ruby minor; rb_* resolve from the
-        # loading interpreter at dlopen (static rubies export
+        # failed to load on 3.4/4.0. Link WITHOUT libruby while
+        # keeping the building Ruby's header ABI: rb_* resolve from
+        # the loading interpreter at dlopen (static rubies export
         # their symbols via -rdynamic, like any extension .so).
-        sh "make native.o"
+        sh "make -B native.o"
         sh "#{RbConfig::CONFIG['CC']} -shared -fPIC -o native.so native.o"
       end
       # Guard the linkage contract at the build chokepoint (#1739):

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.390.2"
+  VERSION = "1.9.391.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.390
+- libleptris v1.9.391
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## [Unreleased]
 
+## [1.9.391] - 2026-10-30
+
+### Fixed
+
+- **XSD: resolve attributeGroup ref rows the pre-pass captured
+  before its imports (leptris-ruby#569, PR #1906).** The #1880
+  attributeGroup pre-pass captures each unit's group defs *before*
+  that unit's imports are chased, so an `<xs:attribute ref="r:embed"/>`
+  row whose declaration lives in a later-imported unit found no
+  global attribute and was silently dropped. Types were left
+  hole-punched (whole-instance validation then rejected `a:blip
+  @r:embed` with "not declared (strict)" on the OOXML `wml.xsd`
+  chain — clean on 1.9.368.1, regressed by the 386-390 wave) or
+  attribute-less, which skipped the strict attribute walk entirely
+  and false-validated foreign attributes. Unresolved ref rows are
+  now kept pending — with the ref's own `use=` override recorded —
+  and re-resolved against the merged top-level attribute table once
+  the whole capture has run; row copies carry the flag so referencing
+  types heal too. Witness: the real uniword `wml.xsd` (1826
+  declarations) compiles clean and a docx-style document with
+  `a:blip r:embed` validates 1.
+
+
+
 ## [1.9.390] - 2026-10-29
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/leptris/xsd/compile.c

@@ -100,6 +100,7 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                              LeptrisElement root);
 static char* xsd_read_file(const char* path, size_t* out_len);
 static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src);
+static void xsd_resolve_pending_attr_refs(struct leptris_xsd_schema* s);
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
                                  const char* name, char* any_attr_ns,
@@ -2021,6 +2022,7 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
 
     xsd_capture_root(s, root);
     xsd_resolve_extension_bases(s);
+    xsd_resolve_pending_attr_refs(s);
 
     leptris_document_free(doc);
     return s;
@@ -3109,6 +3111,7 @@ static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src) {
         d->type = xsd_strdup(src->type);
         d->fixed = xsd_strdup(src->fixed);
         d->required = src->required;
+        d->pending_ref = src->pending_ref;
         if (tail)
             tail->next = d;
         else
@@ -3118,6 +3121,51 @@ static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src) {
     return head;
 }
 
+/* leptris-ruby#569: re-resolve the rows the #1880 attributeGroup
+ * pre-pass captured before the import chase had registered the
+ * referenced unit's top-level attributes. Idempotent; pending rows
+ * that never resolve keep declaring their name (untyped) — the
+ * compile-time ref check already rejects true danglers loudly. */
+#define XSD_PENDING_REF 1
+#define XSD_PENDING_USE 2
+static void xsd_resolve_pending_attr_refs(struct leptris_xsd_schema* s) {
+    if (!s) return;
+    int progressed = 1;
+    while (progressed) {
+        progressed = 0;
+        for (XsdAttrGroupDef* g = s->attr_groups; g; g = g->next)
+            for (XsdAttrDecl* a = g->attrs; a; a = a->next) {
+                if (!(a->pending_ref & XSD_PENDING_REF) || !a->name)
+                    continue;
+                const XsdAttrDecl* src = xsd_find_top_attr(s, a->name);
+                if (!src) continue;
+                free(a->type);
+                free(a->fixed);
+                a->type = xsd_strdup(src->type);
+                a->fixed = xsd_strdup(src->fixed);
+                if (!(a->pending_ref & XSD_PENDING_USE))
+                    a->required = src->required;
+                a->pending_ref &= ~XSD_PENDING_REF;
+                progressed = 1;
+            }
+        for (XsdTypeAttrs* t = s->type_attrs; t; t = t->next)
+            for (XsdAttrDecl* a = t->attrs; a; a = a->next) {
+                if (!(a->pending_ref & XSD_PENDING_REF) || !a->name)
+                    continue;
+                const XsdAttrDecl* src = xsd_find_top_attr(s, a->name);
+                if (!src) continue;
+                free(a->type);
+                free(a->fixed);
+                a->type = xsd_strdup(src->type);
+                a->fixed = xsd_strdup(src->fixed);
+                if (!(a->pending_ref & XSD_PENDING_USE))
+                    a->required = src->required;
+                a->pending_ref &= ~XSD_PENDING_REF;
+                progressed = 1;
+            }
+    }
+}
+
 /* Capture the attribute rows of a complexType or attributeGroup:
  * named rows, inline anonymous simpleTypes (synthesized slots),
  * refs to top-level attributes, and attributeGroup refs. */
@@ -3185,16 +3233,31 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                     leptris_element_attribute(ae, "ref"));
                 const XsdAttrDecl* src =
                     ref ? xsd_find_top_attr(s, ref) : NULL;
-                if (!src) {
+                if (!src && !ref) {
                     free(d);
                     continue;
                 }
-                d->name = xsd_strdup(src->name);
-                d->type = xsd_strdup(src->type);
-                d->fixed = xsd_strdup(src->fixed);
-                d->required = use
-                                  ? (strcmp(use, "required") == 0)
-                                  : src->required;
+                if (!src) {
+                    /* leptris-ruby#569: the #1880 pre-pass captures
+                     * attributeGroup defs BEFORE the import chase
+                     * registers the referenced unit's globals — an
+                     * unresolved ref used to be silently DROPPED
+                     * here, hole-punching the type's rows (a:blip
+                     * @r:embed "not declared (strict)") or leaving
+                     * the type attribute-less so the strict walk
+                     * never ran. Keep the row pending; the
+                     * post-capture fixup resolves it. */
+                    d->name = xsd_strdup(xsd_local_name(ref));
+                    d->pending_ref = use ? 3 : 1;
+                    d->required = (use && strcmp(use, "required") == 0);
+                } else {
+                    d->name = xsd_strdup(src->name);
+                    d->type = xsd_strdup(src->type);
+                    d->fixed = xsd_strdup(src->fixed);
+                    d->required = use
+                                      ? (strcmp(use, "required") == 0)
+                                      : src->required;
+                }
             }
             if (tail)
                 tail->next = d;
@@ -3802,5 +3865,6 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile_set(
         s->base_dir = saved;
     }
     xsd_resolve_extension_bases(s);
+    xsd_resolve_pending_attr_refs(s);
     return s;
 }

data/vendor-src/libleptris/src/leptris/xsd/xsd_internal.h

@@ -197,6 +197,15 @@ typedef struct xsd_attr_decl {
     char* type;  /* builtin ref or local simpleType name (NULL=anySimple) */
     char* fixed; /* #FIXED value: present values must string-equal it */
     int required;
+    /* leptris-ruby#569: the row came from <xs:attribute ref=.../>
+     * whose global declaration was not yet captured (the #1880
+     * attributeGroup pre-pass runs before the import chase). The
+     * row is kept — never silently dropped — and xsd_compile_impl
+     * re-resolves it once the full merged capture has run
+     * (xsd_resolve_pending_attr_refs). bit 0 = ref unresolved,
+     * bit 1 = the ref carried its own use= (it overrides the
+     * declaration's). */
+    int pending_ref;
     struct xsd_attr_decl* next;
 } XsdAttrDecl;
 

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -7,6 +7,7 @@
 #include <gtest/gtest.h>
 
 #include <cstdio>
+#include <fstream>
 #include <cstring>
 #include <string>
 #include <algorithm>
@@ -3680,3 +3681,209 @@ TEST(XsdContent, Issue1894ReproStaysUnderCapAndCorrect) {
     EXPECT_EQ(leptris_xsd_error_count(s), 0u);
     leptris_xsd_free(s);
 }
+
+
+/* leptris-ruby#569 family: cross-namespace references into an
+ * IMPORTED unit. The importing schema must declare xmlns="urn:a"
+ * as the DEFAULT namespace — unprefixed ref QNames resolve to
+ * no-namespace otherwise (spec behavior, the #1901 repro lesson). */
+TEST(XsdCrossNs, AttributeRefIntoImportedUnitResolves) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:simpleType name=\"ST_RelId\">"
+        "<xs:restriction base=\"xs:string\"/></xs:simpleType>"
+        "<xs:attribute name=\"embed\" type=\"ST_RelId\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\" schemaLocation=\"blip_repro_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\" use=\"optional\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/blip_repro_rel.xsd";
+    std::string main_path = base + "/blip_repro_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    const char* paths[2] = {rel_path.c_str(), main_path.c_str()};
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_set(paths, 2, &st);
+    if (st != LEPTRIS_OK || s == (LeptrisXsdSchema)0) {
+        const char* err = s ? leptris_xsd_error(s) : "(no handle)";
+        GTEST_FAIL() << "compile_set failed st=" << (int)st
+                     << " err=" << (err ? err : "(null)");
+    }
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "cross-unit attribute ref must resolve: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* Same shape through the single-document import chase. */
+TEST(XsdCrossNs, SingleDocImportChaseResolves) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:simpleType name=\"ST_RelId\">"
+        "<xs:restriction base=\"xs:string\"/></xs:simpleType>"
+        "<xs:attribute name=\"embed\" type=\"ST_RelId\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\""
+        " schemaLocation=\"blip_repro_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\" use=\"optional\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/blip_repro_rel.xsd";
+    std::string main_path = base + "/blip_repro_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file(main_path.c_str(), &st);
+    if (st != LEPTRIS_OK || s == (LeptrisXsdSchema)0) {
+        const char* err = s ? leptris_xsd_error(s) : "(no handle)";
+        GTEST_FAIL() << "single-doc compile failed st=" << (int)st
+                     << " err=" << (err ? err : "(null)");
+    }
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "import-chase attribute ref must resolve: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* The #569 regression itself: the #1880 attributeGroup pre-pass
+ * captured AG_Blob and resolved its <xs:attribute ref="r:embed"/>
+ * row BEFORE the import chase registered the referenced unit's
+ * r:embed — the row used to be silently dropped, so whole-instance
+ * validation then rejected every a:blip @r:embed ("not declared
+ * (strict)") on the real DrawingML chain. The row must survive as
+ * pending and resolve once the full capture has run. */
+TEST(XsdCrossNs, AttrGroupRefRowResolvedAfterImportChase) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:attribute name=\"embed\" type=\"xs:string\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\" schemaLocation=\"ag569_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/ag569_rel.xsd";
+    std::string main_path = base + "/ag569_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file(main_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* err = leptris_xsd_error(s);
+    ASSERT_EQ(st, LEPTRIS_OK)
+        << "compile failed: " << (err ? err : "(null)");
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "pre-pass ref row must resolve after the import chase: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* leptris-ruby#569: compiling the REAL wml.xsd (ISO transitional,
+ * 790 element decls, import chain to the drawing units) must yield
+ * a cleanly compiled schema — a missing import file poisons the
+ * graph (the '{mce}Ignorable' class), and the merged capture must
+ * carry every unit. The schema set is bundled at $BLIP_CHAIN_DIR
+ * in dev; CI skips when the fixture is absent so the suite stays
+ * hermetic. */
+TEST(XsdCrossNs, RealWmlChainCompilesDeclarations) {
+    const char* dir = std::getenv("BLIP_CHAIN_DIR");
+    if (!dir || *dir == '\0') {
+        GTEST_SKIP() << "BLIP_CHAIN_DIR not set";
+    }
+    std::string wml = std::string(dir) + "/wml.xsd";
+    std::ifstream f(wml);
+    ASSERT_TRUE(f.good()) << wml;
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(wml.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* err = leptris_xsd_error(s);
+    EXPECT_EQ(st, LEPTRIS_OK)
+        << "compile status " << (int)st
+        << " decls=" << leptris_xsd_declaration_count(s)
+        << " err=" << (err ? err : "(clean)");
+    leptris_xsd_free(s);
+}

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.390",
+  "version": "1.9.391",
   "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.390.2
+  version: 1.9.391.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi