lutaml-xsd 1.2.81 → 1.2.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 467b4c2343707af1d200289a1666d12e3ab984c438f0a29ef601d92143914562
-  data.tar.gz: d249de5b32c7fb201c8025cf56af088bde07acb6e1f76d2cd3ae1f15bd39cf29
+  metadata.gz: efe4fbd2d864e7cbe9218faaf7f67fc879c4e20cc32c54e04761fcee59d2d1dc
+  data.tar.gz: 3b5618daa924a8a493645bab5ea7f0408d3b9245c32695306131c1cb9a0cfeb8
 SHA512:
-  metadata.gz: 0f9c9c9c71bf3e064dd93ab6e007df3f9d90aaad2478bf77d8f7b7915804b5e8218a6d8adb97be02293560dc261ed957a6fe09af5404a30b18ee7a0d5d1a941e
-  data.tar.gz: 539a1503358510cde20356dc3d6a0a1a2c0b9daaebf77bda9ef45bc54f45222a0eaf2d97477b05f1347b1d35dcc22742963b0fc388823217bc6cd45ceb900bdf
+  metadata.gz: 909c81244dd126cbbb8843fcd3a010f5da4a3c70bd325b71ed5865496cc390d101fecb6d6a4c38069b350abad064c4837328f5ee28cdcb583b4ec5e439c629da
+  data.tar.gz: 34a60915d85511b36be444dc6903e8f3f221e6740d3d6147fd5966c0fe82a852896dffb20fbf6253376bb78abeaa4a2717da83b4b44e644739acda1e85105c33

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4573/4696 (97.38%) |
+| pipeline | 4585/4696 (97.64%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -142,7 +142,9 @@ lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 4436 (94.5%) → 4439 (94.5%) → 4454 (94.9%) → 4495 (95.7%) → 4524
 (96.3%) → 4534 (96.6%) → 4540 (96.7%) → 4542 (96.7%) → 4546 (96.8%)
 → 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
-4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content round), +612 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content
+round) → 4578 (97.49%, attribute-prohibition round) → 4585 (97.64%,
+multi-document round), +624 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
 \w/\W/\s to their XSD value spaces) collapses Regex 120→69;
 same-step pattern facets now behave as alternatives and
 whitespace-only text reaches the facets intact (PR #200), Regex
@@ -232,15 +234,19 @@ corners.
 
 | Class | Cases | Filed |
 |---|---|---|
-| Facade strict re-check on composed schemas — remaining shapes (ctE019 attribute re-check, addB116 substitution admission) | ~8 | moxml#510 (+2 follow-up comments) |
-| Redefine self-extension drops the extension content model | 0 — FIXED in leptris 1.9.396 | leptris#1926 (closed) |
-| Built-in lexical tables reject valid forms (char-reference shapes; gMonth FIXED 1.9.398, \d legacy-Nd FIXED 1.9.399, stG/stH list lexicals FIXED 1.9.400/401) | ~5 | leptris#1936 |
-| Automaton size cap surfaces as an instance error instead of engine-inert silence | 0 — FIXED in leptris 1.9.398 | moxml#514 (follow-up to #473) |
-| Regex dialect remainder (engine `\d` vintage, `\p{Is...}` blocks, char-reference shapes) | ~30 | engine-side of leptris#1936 |
-| Empty content against a fixed element value rejected (1.9.402.0 regression — isDefault001/002/076, ctZ013a, elemQ019, stE065/066/096, particlesZ040) | 9 | leptris-rs#25 |
+| Empty content against a fixed element value rejected (1.9.402.0 regression — isDefault001/002/076, ctZ013a, elemQ019, stE065/066/096, particlesZ040; attribute leg addB104, attO006) | 15 | leptris-rs#25 (+ case-list comment) |
+| Content model enforced on NILLED elements (QFE1700g2, particlesIa002) | 2 | leptris-rs#26 |
+| dateTime enumeration rejects timezone-equal forms (dateTime_enumeration005a/b) | 2 | leptris-rs#27 |
+| "-0" rejected against nonNegativeInteger (errE002) | 1 | leptris-rs#28 |
+| xsi:type override / substitution-member type binding false rejects (elemZ002, elemZ020) | 2 | leptris-rs#29 |
+| Built-in lexical tables (char-reference shapes reZ003v/004v/005v/006v/006i, reK88; \D vintage reT51) | 7 | leptris/leptris#1936 (+ case-list comment) |
+| Facade strict re-check on composed schemas — attributes (attgD005/019/020/021/022/025/027/029/031/033/034, attJ018) and composed type binding (schF1/G2/G7/P2) | 15 | moxml#510 (+ consolidated evidence comment) |
 | Unresolvable include/import/redefine schemaLocation raises at parse instead of warning (anyURI_a001/a002, schD7, schG8) | 4 | lutaml-model#1087 |
-| Strict wildcard/attribute admission on further compositions | ~5 | moxml#510 thread |
-| Ruby-side under-detections (Group 16, DataTypes 7, IC 6, Attribute 5, Additional 4, Particles 4, SimpleType 4, Element 1, Wildcards 1 — minus what the regex round banked) | ~60 | OURS — the remaining Ruby work queue |
+| Automaton size cap surfaces as an instance error instead of engine-inert silence | 0 — FIXED in leptris 1.9.398 | moxml#514 (follow-up to #473) |
+| Redefine self-extension drops the extension content model | 0 — FIXED in leptris 1.9.396 | leptris#1926 (closed) |
+| Ruby-side under-detections and false rejects (Regex dialect 18 — reJ/reS/reDH disputed families excluded; DataTypes corners duration028-030/dateTime013/gMonthDay006/dtZ86723; IC idK/idZ singletons; SimpleType stZ; Wildcards wildZ013; Group/Particles stragglers; Schema schT/D10/F2/errC007; Q032 chameleon import; particlesA013/A002/Ie004/Ig003/Ob012/015/Z001; mgO006/034; attF001/attJ002/003/attLa005; isDefault079) | ~55 | OURS — the remaining Ruby work queue |
+
+Engine-attribution census (2026-11-03): of the 123 current failures, 50 carry engine findings (all attributed above), 73 are Ruby-side.
 
 Suite history (same-stack where known): 71.8% baseline → 83.5%
 (pre-NFA) → 83.6% (NFA + guard, 1.2.41) → 84.3% (#180) → 86.0%
@@ -450,6 +456,44 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   import; our index keeps them no-namespace so the four e2 refs
   mis-resolve). Zero regressions; the drift entries above remain
   (fixed-empty 9, reU6).
+- ATTRIBUTE-PROHIBITION ROUND (2026-11-03): +5 Attribute (9→4,
+  attF001/J002/J003/Z007i under-detections + attLa005 fixed-facet;
+  suite 4573→4578 = 97.49%, ZERO regressions, rspec green).
+  use=prohibited was never enforced — instances could carry a
+  prohibited attribute unchecked. The declaration binds now, with
+  THREE suite-arbitrated exemptions for incoherent shapes: a
+  wildcard admitting the attribute shadows it (attZ002); fixed +
+  prohibited is an illegal combo treated as inert (attP031); a
+  prohibited member inside an attributeGroup DEFINITION is illegal
+  placement the suite ignores (attZ015). A derived type's OWN
+  declaration overrides the base chain's prohibited (attZ007v) while
+  a restriction body's own prohibited stands (attZ007i). A ref's
+  use-site fixed overlays the global declaration in the value check
+  (attLa005). Attribute remainder (4): attJ018 + attO009/011
+  (engine-silent — queue), attO006 (leptris-rs#25 attribute leg).
+- MULTI-DOCUMENT ROUND (2026-11-03): +7 (Schema 12→9 — the schT3/T9/
+  T10 redefine trio; ComplexType 4→1, Particles 12→10, Additional
+  10→9, IC 7→6 — same-namespace collision pairs; suite 4578→4585 =
+  97.64%, zero regressions, rspec green). TWO defects: (a) the
+  conformance repository keyed documents by TARGET NAMESPACE, so two
+  schemaDocuments sharing a namespace silently overwrote each other
+  and only one survived (schT3's redefine pair, both ns-a); a
+  same-namespace collision now suffixes the key instead of dropping
+  the document — every other case keeps the production one-doc-per-
+  namespace semantics (a naive path-key for everything cost 25
+  regressions via the unique-name fallback and first-match type
+  lookup, caught and reverted in-round). (b) resolve_named_type now
+  falls back to the parsed xs:redefine target documents: types living
+  only in the target (schT3 b-ct/b-st) resolve for plain references;
+  names a redefine BODY redefines stay OFF that path (the body is the
+  effective type and is not resolvable here — idF/idG/idH keep the
+  lenient path). KNOWN GAPS left open: schA1/schQ1/schD10/schF2
+  (hint-composition with same-local-name ct-A across namespaces —
+  per-namespace type binding), full type-redefine body semantics
+  (the body as effective type with the self-base hook — a
+  lutaml-model Redefine model shape study). Remaining Schema 9:
+  schA1/Q1/D10/F2 (ours), schD7/G8 (lutaml-model#1087),
+  schF1/G2/G7/P2 (moxml#510 composed bindings).
 - REGEX SEMANTICS ROUND (2026-10-31, PR #208): \w/\W now carry their
   Appendix F complements (\w = [^\p{P}\p{Z}\p{C}], class interiors
   via the exact positive partition L/M/N/S), \I/\C complements added

data/lib/lutaml/xsd/conformance/w3c_suite.rb

@@ -154,8 +154,17 @@ module Lutaml
           test_case.schema_paths.each do |path|
             schema = Lutaml::Xml::Schema::Xsd.parse(File.read(path),
                                                     location: path)
-            key = schema.target_namespace if
-              schema.target_namespace.to_s.match?(/\S/)
+            # Keyed by target namespace like production, EXCEPT that a
+            # same-namespace collision suffixes the key instead of
+            # dropping the document (schT3's redefine pair both declare
+            # ns-a). The resolver iterates values; keys only need to
+            # keep every document present.
+            key = if schema.target_namespace.to_s.match?(/\S/)
+                    schema.target_namespace
+                  else
+                    path
+                  end
+            key = "#{key}##{path}" while schemas.key?(key)
             schemas[key] = schema
             locations[path] = schema
           end

data/lib/lutaml/xsd/validation/rules/attribute_validation_rule.rb

@@ -94,11 +94,24 @@ module Lutaml
                                          resolved_attributes,
                                          xml_attributes, collector)
 
+            # Step 1b: Check prohibited attributes are absent — the
+            # declaration exists, its USE does not (attF001). Three
+            # suite-arbitrated exemptions: a wildcard that admits the
+            # attribute shadows the prohibition (attZ002); fixed plus
+            # prohibited is an illegal declaration combo and the suite
+            # treats the whole declaration as inert (attP031); and a
+            # prohibition arriving through DERIVATION is refinement
+            # incoherence the suite ignores (attZ007v, attZ015).
+            validate_prohibited_attributes(xml_element, schema_attributes,
+                                           xml_attributes, collector,
+                                           wildcards: wildcards)
+
             # Step 2: Validate attribute values
             validate_attribute_values(xml_element, resolved_attributes,
                                       xml_attributes, collector,
                                       repository: repository,
-                                      schema_element: schema_element)
+                                      schema_element: schema_element,
+                                      raw_attrs: schema_attributes)
 
             # Step 3: Check for unexpected attributes
             validate_no_unexpected_attributes(xml_element,
@@ -209,7 +222,11 @@ module Lutaml
               # Base attributes flow through both derivations — a
               # restriction narrows them but cannot drop them (XSD 1.0
               # §3.4.2).
-              attributes.concat(inherited_attributes(part.base, repository)) if part
+              if part
+                attributes.concat(
+                  inherited_attributes(part, repository),
+                )
+              end
             end
 
             # Handle simple content
@@ -221,18 +238,50 @@ module Lutaml
               )
               part = Array(schema_def.simple_content.extension).first ||
                 Array(schema_def.simple_content.restriction).first
-              attributes.concat(inherited_attributes(part.base, repository)) if part
+              if part
+                attributes.concat(
+                  inherited_attributes(part, repository),
+                )
+              end
             end
 
+            override_base_prohibitions(schema_def, attributes)
             attributes
           end
 
+          # A derived type's OWN (type-level or derivation-body)
+          # non-prohibited declaration for a name overrides the base
+          # chain's prohibited (attZ007v: the extension re-adds att1
+          # required over Two's prohibited). A restriction body's own
+          # prohibited stands against the inherited plain declaration
+          # (attZ007i: e2 carrying att1 is invalid).
+          #
+          # @return [void]
+          def override_base_prohibitions(schema_def, attributes)
+            own_declarations = Array(schema_def.attribute)
+            content = schema_def.complex_content || schema_def.simple_content
+            CONTENT_PART_KINDS.each do |kind|
+              part = content && Array(content.public_send(kind)).first
+              own_declarations += Array(part&.attribute) if part
+            end
+            own_names = own_declarations
+              .reject { |a| a.use.to_s == "prohibited" }
+              .map { |a| a.name.to_s }
+            attributes.reject! do |a|
+              a.use.to_s == "prohibited" &&
+                own_names.include?(a.name.to_s) &&
+                !own_declarations.include?(a)
+            end
+          end
+
           # The base type's attribute set flows into the derived type
-          # through extension and restriction alike.
+          # through extension and restriction alike. The base resolves
+          # through the derivation so a redefine body's own base hooks
+          # to the original definition.
           #
           # @return [Array<Lutaml::Xml::Schema::Xsd::Attribute>]
-          def inherited_attributes(base_name, repository)
-            local = base_name.to_s.split(":").last
+          def inherited_attributes(part, repository)
+            local = part.base.to_s.split(":").last
             return [] if local.to_s.empty?
 
             base = repository&.resolve_named_type(local)
@@ -275,7 +324,11 @@ module Lutaml
             return [] unless group
 
             own = (group.name || group.ref).to_s.split(":").last
-            attrs = Array(group.attribute)
+            # use=prohibited is illegal inside an attributeGroup
+            # DEFINITION (attZ015): the suite ignores such members.
+            attrs = Array(group.attribute).reject do |attr|
+              attr.use.to_s == "prohibited"
+            end
 
             # An attributeGroup may reference other attributeGroups —
             # their declarations flow into the expansion (attgD004). A
@@ -393,6 +446,44 @@ module Lutaml
             schema_attr.use == "required"
           end
 
+          # A prohibited attribute is DECLARED but its use is banned:
+          # any instance occurrence violates the schema (attF001).
+          #
+          # @return [void]
+          def validate_prohibited_attributes(xml_element, schema_attrs,
+                                             xml_attrs, collector,
+                                             wildcards: [])
+            schema_attrs.each do |schema_attr|
+              next unless schema_attr.use.to_s == "prohibited"
+              # fixed + prohibited is an illegal declaration combo
+              # (attP031): the suite treats the declaration as inert.
+              next if schema_attr.fixed
+
+              attr_name = schema_attr.name.to_s
+              next if attr_name.empty?
+
+              xml_attr = xml_attrs.find { |xa| xa.name == attr_name }
+              next unless xml_attr
+              next if wildcards.any? do |wildcard|
+                wildcard_permits_attribute?(wildcard, xml_element, xml_attr,
+                                            nil)
+              end
+
+              report_error(
+                collector,
+                code: "prohibited_attribute_present",
+                message: "Attribute '#{attr_name}' is prohibited here " \
+                         "but present",
+                location: xml_element.xpath,
+                context: {
+                  attribute: attr_name,
+                  element: xml_element.name,
+                },
+                suggestion: "Remove attribute: #{attr_name}",
+              )
+            end
+          end
+
           # Validate attribute values
           #
           # @param xml_element [XmlElement] The element
@@ -402,14 +493,23 @@ module Lutaml
           # @return [void]
           def validate_attribute_values(xml_element, schema_attrs, xml_attrs,
                                         collector, repository: nil,
-                                        schema_element: nil)
+                                        schema_element: nil, raw_attrs: [])
             xml_attrs.each do |xml_attr|
               schema_attr = find_schema_attribute(schema_attrs, xml_attr,
                                                   repository, schema_element)
               next unless schema_attr
 
+              # A ref's use site may carry facets the global declaration
+              # lacks (attLa005: ref="x:ga1" fixed="abc" at the use
+              # site); the instance value is checked against them too.
+              use_site = raw_attrs.find do |r|
+                r.name == schema_attr.name ||
+                  r.ref.to_s.split(":").last == schema_attr.name
+              end
               validate_attribute_value(xml_element, xml_attr, schema_attr,
-                                       collector, repository: repository)
+                                       collector,
+                                       repository: repository,
+                                       use_site: use_site)
             end
           end
 
@@ -461,10 +561,11 @@ module Lutaml
           # "123").
           #
           # @return [Boolean]
-          def fixed_value_matches?(value, schema_attr)
+          def fixed_value_matches?(value, schema_attr, fixed_override = nil)
+            fixed = fixed_override || schema_attr.fixed
             rule = attribute_whitespace_rule(schema_attr)
             canonical_lexical(value, rule) ==
-              canonical_lexical(schema_attr.fixed, rule)
+              canonical_lexical(fixed, rule)
           end
 
           # @return [Symbol] :preserve, :replace or :collapse
@@ -499,21 +600,27 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_attribute_value(xml_element, xml_attr, schema_attr,
-                                       collector, repository: nil)
+                                       collector, repository: nil,
+                                       use_site: nil)
             value = xml_attr.value
+            fixed = if use_site && !use_site.fixed.nil?
+                      use_site.fixed
+                    else
+                      schema_attr.fixed
+                    end
 
             # Check fixed value constraint
-            if schema_attr.fixed
-              unless fixed_value_matches?(value, schema_attr)
+            if fixed
+              unless fixed_value_matches?(value, schema_attr, fixed)
                 report_error(
                   collector,
                   code: "fixed_attribute_value_mismatch",
                   message: "Attribute '#{xml_attr.name}' must have fixed " \
-                           "value '#{schema_attr.fixed}'",
+                           "value '#{fixed}'",
                   location: xml_element.xpath,
                   context: {
                     attribute: xml_attr.name,
-                    expected: schema_attr.fixed,
+                    expected: fixed,
                     actual: value,
                   },
                 )

data/lib/lutaml/xsd/validation/rules/content_model_validation_rule.rb

@@ -302,7 +302,8 @@ module Lutaml
               restriction = Array(content.restriction).first
               if extension
                 base_local = extension.base.to_s.split(":").last
-                base_type = base_local && repository&.resolve_named_type(base_local)
+                base_type = base_local &&
+                  repository&.resolve_named_type(base_local)
                 particles = type_particles(base_type, repository, seen) +
                   particles
                 COMPLEX_PARTICLE_KINDS.each do |kind|

data/lib/lutaml/xsd/validation/schema_definition_resolver.rb

@@ -50,6 +50,14 @@ module Lutaml
           @attributes = Hash.new { |hash, key| hash[key] = [] }
           @attribute_groups = {}
           @redefined_originals = {}
+          # Parsed xs:redefine target documents: their named types back
+          # the redefined bodies (schT3: b-ct/b-st live in the target,
+          # which the repository does not hold). Names a redefine BODY
+          # redefines are NOT served from the target: the body is the
+          # effective type and is not resolvable here, so those keep
+          # the lenient unresolvable path (idF/idG/idH class).
+          @redefined_targets = []
+          @redefined_body_names = []
           @elements = index_elements
         end
 
@@ -200,18 +208,29 @@ module Lutaml
 
           result = nil
           schemas.each do |schema|
-            found = Array(schema.complex_type).find do |ct|
-              ct.name == local_name
-            end
-            found ||= Array(schema.simple_type).find do |st|
-              st.name == local_name
-            end
-            result = found || find_nested_named_type(local_name, schema)
+            result = named_type_in(local_name, schema)
             break if result
           end
+          if result.nil? && !@redefined_body_names.include?(local_name)
+            @redefined_targets.each do |schema|
+              result = named_type_in(local_name, schema)
+              break if result
+            end
+          end
           @named_types[local_name] = result
         end
 
+        # @return [Object, nil]
+        def named_type_in(local_name, schema)
+          found = Array(schema.complex_type).find do |ct|
+            ct.name == local_name
+          end
+          found ||= Array(schema.simple_type).find do |st|
+            st.name == local_name
+          end
+          found || find_nested_named_type(local_name, schema)
+        end
+
         # Named types declared in documents reached through resolved
         # includes/imports — chameleon types (ctE018) live in a
         # no-namespace include target.
@@ -602,35 +621,60 @@ module Lutaml
           # indexed under the name (attgC007/attgD036). Runs after the
           # nested descent so included declarations are already in.
           Array(schema.redefine).each do |red|
-            target_path = nil
-            base = begin
-              File.dirname(@repository.source_path_for(schema))
+            index_redefine(index, schema, red, held_signatures, namespace,
+                           defaults_schema)
+          end
+        end
+
+        # xs:redefine replaces an attributeGroup with a body whose
+        # self-reference is the §4.2.2 hook to the ORIGINAL
+        # definition. lutaml-model does NOT chase the redefine
+        # target, so the original document is parsed here (relative
+        # to the defining file) and indexed; the original
+        # declaration is kept for that hook and the redefining body
+        # indexed under the name (attgC007/attgD036). Runs after the
+        # nested descent so included declarations are already in.
+        def index_redefine(index, schema, red, held_signatures, namespace,
+                           defaults_schema)
+          target_path = nil
+          base = begin
+            File.dirname(@repository.source_path_for(schema))
+          rescue StandardError
+            nil
+          end
+          if base && red.schema_path.to_s.match?(/\S/)
+            candidate = File.expand_path(red.schema_path.to_s, base)
+            target_path = candidate if File.exist?(candidate)
+          end
+          if target_path
+            begin
+              target = Lutaml::Xml::Schema::Xsd.parse(
+                File.read(target_path), location: target_path
+              )
+              @redefined_targets << target
+              index_schema(index, target, held_signatures, namespace,
+                           defaults_schema)
             rescue StandardError
               nil
             end
-            if base && red.schema_path.to_s.match?(/\S/)
-              candidate = File.expand_path(red.schema_path.to_s, base)
-              target_path = candidate if File.exist?(candidate)
-            end
-            if target_path
-              begin
-                target = Lutaml::Xml::Schema::Xsd.parse(
-                  File.read(target_path), location: target_path
-                )
-                index_schema(index, target, held_signatures, namespace,
-                             defaults_schema)
-              rescue StandardError
-                nil
-              end
-            end
-            Array(red.attribute_group).each do |group|
-              name = group.name.to_s
-              next if name.empty?
+          end
+          # Names the body redefines: served by the body (not
+          # resolvable here), never by the target originals.
+          Array(red.complex_type).each do |body|
+            name = body.name.to_s
+            @redefined_body_names << name unless name.empty?
+          end
+          Array(red.simple_type).each do |body|
+            name = body.name.to_s
+            @redefined_body_names << name unless name.empty?
+          end
+          Array(red.attribute_group).each do |group|
+            name = group.name.to_s
+            next if name.empty?
 
-              original = @attribute_groups[name]
-              @redefined_originals[name] = original if original
-              @attribute_groups[name] = group
-            end
+            original = @attribute_groups[name]
+            @redefined_originals[name] = original if original
+            @attribute_groups[name] = group
           end
         end
 

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.81"
+    VERSION = "1.2.83"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.81
+  version: 1.2.83
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-02 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid