lutaml-xsd 1.2.113 → 1.2.115

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ef5ebe654a09dce031fef237b193d2f537550b3f6e05e234214fe2c9bba8a21
-  data.tar.gz: bde3cb46ee3b74ea6a2812d98b69c73e8ea5ad5f7a89a838350a290a76917eec
+  metadata.gz: 8361d002b4925f8e9617b1befc010cdf69eda020d9819ad6cb563d5716fd0cb3
+  data.tar.gz: d7ee489b009dbfe0f537b6ec11ea9e68435161619db337801a8b2fe44881b267
 SHA512:
-  metadata.gz: df70a1340ca701bebd079dcd7b514f1657c5aa2a9e4117127a3003fdb0a63487aeb44e981da443b40801194e556be881f181d729cced3d0ed8fc07b08191e4f1
-  data.tar.gz: 90623814fed971c9c310f00ea3f1de694b624a15d634a0452e263786bdb3b934891023431af787bfe0cfdc2146bef9f9a3ce29f201d86e85401d3304648c68a5
+  metadata.gz: a67d033744fd14e969811aed1d8b7f7e679a50b2c535a1ea649e670d5e4baf6f5fef3c5b11349cfef519dbfb0cdacdc467270ccf6c3c231d3f6f234b2c7f84b2
+  data.tar.gz: 02fec25f4e6c24ecf8c591e8fff9dfb245acaeacb41a09c36223ae6a1da1cdc8e35a22c215b2a11c137982b1d49c284c568e926faf49d856bcc52f68a13be1a3

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4649/4696 (98.91%) — FIRST FULL-DENOMINATOR MEASURE, all 94 batches in one rake run |
+| pipeline | 4664/4696 (99.32%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -144,7 +144,7 @@ lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 → 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
 4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content
 round) → 4578 (97.49%, attribute-prohibition round) → 4585 (97.64%,
-multi-document round) → 4588 (97.7%, type-binding round) → 4592 (97.79%, model-161 ride) → 4611 (98.19%, engine-406 ride) → 4613 (98.23%, temporal-enumeration round) → 4614 (98.25%, simple-type-children round) → 4617 (98.32%, ic-ancestor-scope round) → 4637 (parent-context rounds + chameleon round 1.2.109) → 4637 (nested-type-candidates round, 1.2.110) → 4637 (redefine-cycle round, 1.2.111) → 4644 measured (98.96% of measured, train-adoption round: moxml 0.6.6 + leptris 1.9.418.0) → 4649 (98.91%, quadratic-dispatch round — first FULL-denominator measure, the 5 reZ budget exclusions retired), +688 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+multi-document round) → 4588 (97.7%, type-binding round) → 4592 (97.79%, model-161 ride) → 4611 (98.19%, engine-406 ride) → 4613 (98.23%, temporal-enumeration round) → 4614 (98.25%, simple-type-children round) → 4617 (98.32%, ic-ancestor-scope round) → 4637 (parent-context rounds + chameleon round 1.2.109) → 4637 (nested-type-candidates round, 1.2.110) → 4637 (redefine-cycle round, 1.2.111) → 4644 measured (98.96% of measured, train-adoption round: moxml 0.6.6 + leptris 1.9.418.0) → 4649 (98.91%, quadratic-dispatch round — first FULL-denominator measure, the 5 reZ budget exclusions retired) → 4658 (99.19%, remainder-classification round — first measure above 99) → 4664 (99.32%, ride-419 round), +703 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
@@ -638,6 +638,84 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   ledger (47 still-failing in both — the standing remainder:
   contested 24, the upstream filings' legs, the parked redesign
   tails).
+- REMAINDER-CLASSIFICATION ROUND (2026-11-12, release pending):
+  the live ledger re-derived the queue (the memory's schA1/D10
+  gaps were STALE — all three pass since the chameleon/type-
+  binding rounds); the 47-case remainder splits into 13
+  filed-upstream, ~25 contested/disputed, and NINE ours. ALL
+  NINE FIXED, zero regressions — four mechanism families:
+  (a) DERIVATION COMPLETENESS (stZ054/055/056/073b/ba): §4.1.2
+  anySimpleType is the ur-simple root — EVERY simple type derives
+  from it, restriction-of-builtin chains and pure lists/unions
+  alike, and a simpleContent derivation over a builtin reaches it
+  transitively; a BUILTIN override owes the §3.3.4 check against
+  NAMED declared types via the BUILTIN_ANCESTORS table
+  (ValueSpace) — identity or declared-in-ancestry, xs:anyType
+  derives from nothing but itself (stZ056), restriction-of-union
+  does NOT admit members (stZ073b), direct unions do (the
+  elemT071 rule, builtin members included). (b) NFA LOOP-BRANCH
+  BYPASS (particlesA013 + the matcher probe): with_occurrence's
+  unbounded branch wired ε-edges from the FIRST body copy's exit
+  to final — with min ≥ 2 those bypass the mandatory unrolled
+  copies and accept after one consumption; the edges are
+  redundant at min ≤ 1 (cursor == exit_state) and removed.
+  (c) CHOICE-MIN EMPTY BRANCH (particlesIe004): a branch whose
+  minimum is zero satisfies the choice with the EMPTY sequence —
+  the choice's own minimum cannot fail on a zero count.
+  (d) BLOCK IN WHOLE OR IN PART + EXTENSION TEXT (particlesIg003,
+  addB114): §3.3.4 blocks the derivation CHAIN — any_type_chain_
+  kinds walks every hop to the ur-type (a bare complexType
+  restricts anyType per §3.4.3, so ext→base→anyType carries a
+  restriction hop that block="restriction" catches), and a
+  simpleContent EXTENSION's text validates against the
+  extension's base type (addB114: '62' violates base A's facets
+  through E-A; the branch previously had only a comment).
+  Also routed products AT the OccurrenceProductGuard cap to the
+  Ruby NFA (`< CAP` — the engine answers lax on wildcard
+  minimums there) and admitted the parsed Xml::Schema::Xsd::Any
+  class to PARTICLE_TYPES + the matcher wildcard dispatch.
+  SUITE 4658/4696 (99.19%) — first measure above 99; rspec 1663
+  green; rubocop clean. REMAINDER 38: 13 filed-upstream
+  (leptris-rs#72/#73, #45 legs, attgC035-038), ~25
+  contested/disputed (reJ 14, reS/reT/reU/reDH vintages,
+  attZ014a/b 1.1 drift, gMonth_pattern/double018, particlesZ001).
+  TOOLING NOTE: rubocop -A broke the tri-state
+  builtin_derivation_cover — the nil ("not a builtin") became
+  false, which would have flagged every schema-type override
+  undervalued; caught by re-reading the -A diff (the standing
+  predicate-nil lesson, now with the rename fix applied).
+- RIDE-419 ROUND (2026-11-13, release pending): leptris
+  1.9.419.0 closed BOTH overnight filings — leptris-rs#72
+  (wildZ013b/c: the namespace-less-import wildcard admission
+  restored) and #73 (attZ014a/b: the multi-xs:ID 1.0 reading
+  restored). The ride also surfaced that OUR fixed-value check
+  was lexical-only where the suite demands VALUE-space equality
+  through a union's first-accepting member (§4.1.7): stE050
+  ('true' == fixed '1' as boolean-true) and stE055 (float forms)
+  now pass via ValueSpace.union_member_value_key + the
+  fixed_value_space_equal? comparison in TypeValidationRule
+  (union members split per the established member_types.to_s.
+  split pattern — Array() on the attribute yields ONE
+  space-separated string, which silently never matches; three
+  call sites corrected, including a latent one from the previous
+  round). stE065/066/096 remain ENGINE-bound — filed
+  leptris-rs#74 (the engine's own fixed-value comparison is
+  lexical-only for unions); attgC035-038 remain FACADE-bound —
+  filed moxml#545 (the closed-#522 thread's uncovered legs: the
+  strict re-check false-reports attributeGroup-redefine §4.2.2
+  hook members). SUITE 4664/4696 (99.32%), zero regressions;
+  rspec 1663 green; rubocop clean. INCIDENT (recovered
+  in-round): threading repository: into validate_fixed_content
+  via a bulk gsub landed a call inside validate_builtin_type,
+  whose scope has no repository local — NameError on every
+  builtin-typed element, a 686-case regression wave that
+  briefly looked like a leptris-419 breakage; the pin-back
+  battery exonerated the train (the wave reproduced on 418)
+  and the signature fix recovered the battery. LESSON: when
+  threading a parameter through call sites, verify the RECEIVER
+  method's signature carries it — a mechanical gsub crosses
+  scope boundaries silently, and the crash-as-invalid
+  convention turns the NameError into wholesale false verdicts.
 - TRAIN ADOPTION REGRESSION — CHARACTER REFERENCES (2026-11-11):
   the 2026-11-10 adoption verdict ("conformance-IDENTICAL") was
   WRONG for one class: moxml 0.6.4 stopped decoding numeric

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

@@ -195,7 +195,7 @@ module Lutaml
             with_occurrence(particle) { compile_all(particle) }
           when Lutaml::Xml::Schema::Xsd::Group
             compile_group(particle)
-          when Lutaml::Xsd::Any
+          when Lutaml::Xsd::Any, Lutaml::Xml::Schema::Xsd::Any
             with_occurrence(particle) { leaf_fragment(:wildcard, particle) }
           else
             with_occurrence(particle) { leaf_fragment(:element, particle) }
@@ -330,10 +330,13 @@ module Lutaml
           @epsilons[entry] << final if min.zero?
           if max == UNBOUNDED || min > MAX_UNROLL ||
               (max != UNBOUNDED && max - min > MAX_UNROLL)
+            # Loop-or-finish from the LAST mandatory copy's exit only.
+            # The first copy's exit must NOT shortcut to final — with
+            # min >= 2 the ε-edge would bypass the mandatory copies and
+            # accept after one consumption (particlesA013: any min=2
+            # matched by a single child).
             @epsilons[cursor] << last_entry
             @epsilons[cursor] << final
-            @epsilons[exit_state] << last_entry
-            @epsilons[exit_state] << final
           else
             @epsilons[cursor] << final
             optional = max - min - (min.zero? && max.is_a?(Integer) ? 1 : 0)

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

@@ -62,7 +62,11 @@ module Lutaml
         end
 
         def particles_safe?(particles)
-          particles.all? { |particle| product(particle, 1, 0) <= CAP }
+          # Products AT the cap route to the Ruby NFA too — the engine
+          # compiles them into exactly the automata this guard exists
+          # to avoid (particlesA013: any min=2 max=1000000; the engine
+          # answers lax on the wildcard minimum there).
+          particles.all? { |particle| product(particle, 1, 0) < CAP }
         end
 
         # Walks a type's content model. Nested elements referencing
@@ -80,7 +84,7 @@ module Lutaml
               expanded = @group_expander&.call(particle)
               expanded && particles_safe?(expanded)
             else
-              product(particle, 1, 0) <= CAP
+              product(particle, 1, 0) < CAP
             end
           end
         end

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

@@ -37,6 +37,7 @@ module Lutaml
           PARTICLE_TYPES = [
             Lutaml::Xsd::Element,
             Lutaml::Xsd::Any,
+            Lutaml::Xml::Schema::Xsd::Any,
             Lutaml::Xsd::Sequence,
             Lutaml::Xsd::Choice,
             Lutaml::Xsd::All,

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

@@ -415,7 +415,15 @@ module Lutaml
                                                       repository)
             occurrence_count = choice_occurrence_count(present_count, choice, repository)
 
-            if occurrence_count < min_occurs
+            # A branch whose occurrence minimum is zero satisfies the
+            # choice with the EMPTY sequence (XSD particle semantics),
+            # so the choice's own minimum cannot fail on a zero count
+            # (particlesIe004: choice(e1 1, e2 0) against an empty doc).
+            empty_branch = choice_alternatives(choice).any? do |alt|
+              parse_occurs(alt.min_occurs, 1).zero?
+            end
+
+            if occurrence_count < min_occurs && !empty_branch
               report_error(
                 collector,
                 code: "choice_min_occurs_violation",

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

@@ -26,6 +26,14 @@ module Lutaml
           include EngineBacked
           include ValueSpace
 
+          # The ur-simple root: every simple type derives from it
+          # (XSD 1.0 §4.1.2).
+          ANY_SIMPLE_TYPE_LOCAL = "anySimpleType"
+
+          # The ur-type: root of the type hierarchy, derives from
+          # nothing but itself.
+          ANY_TYPE_LOCAL = "anyType"
+
           # Rule category
           #
           # @return [Symbol] :type
@@ -62,14 +70,14 @@ module Lutaml
                                           repository)
               unless type_def
                 # xsi:type may name a built-in — resolve_named_type only
-                # sees schema documents (addB028).
-                if builtin_override_reference(xml_element)
-                  validate_builtin_type(xml_element,
-                                        builtin_override_reference(xml_element),
-                                        collector,
-                                        declared: schema_element)
-                  return
-                end
+                # sees schema documents (addB028). A builtin override
+                # still owes the §3.3.4 derivation against the declared
+                # type: anyType derives from nothing else, so overriding
+                # an anySimpleType declaration with xs:anyType is
+                # invalid (stZ056).
+                return if builtin_override_reference(xml_element) &&
+                  builtin_override_handled?(xml_element, schema_element,
+                                            collector, repository)
 
                 report_error(
                   collector,
@@ -119,7 +127,8 @@ module Lutaml
               # A type-less declaration is xs:anyType; its fixed value
               # still constrains the lexical content (isDefault070).
               validate_fixed_content(xml_element, schema_element,
-                                     xml_element.text_content, collector)
+                                     xml_element.text_content, collector,
+                                     repository: repository)
               return
             end
 
@@ -135,12 +144,16 @@ module Lutaml
               # complex walk checks the type's model, this checks the
               # declaration's own fixed content (isDefault077).
               validate_fixed_content(xml_element, schema_element,
-                                     xml_element.text_content, collector)
-              validate_complex_type_content(xml_element, type_def, collector)
+                                     xml_element.text_content, collector,
+                                     repository: repository)
+              validate_complex_type_content(xml_element, type_def, collector,
+                                            repository: repository,
+                                            declared: schema_element)
             else
               # Handle built-in types
               validate_builtin_type(xml_element, type_def, collector,
-                                    declared: schema_element)
+                                    declared: schema_element,
+                                    repository: repository)
             end
           end
 
@@ -172,7 +185,12 @@ module Lutaml
           # from one (elemT071); the override's block-kind comes from
           # the member chain (elemT074). Complex types derive through
           # both content kinds — a simpleContent extension of a simple
-          # base is a derivation too (elemT058).
+          # base is a derivation too (elemT058). anySimpleType is the
+          # ur-simple root (§4.1.2): EVERY simple type derives from it
+          # — restriction-of-builtin chains and pure lists/unions alike
+          # (stZ054) — and a simpleContent derivation over a builtin
+          # base reaches it transitively (stZ055's extension of
+          # xs:string).
           #
           # @return [Boolean]
           def validly_derived?(type, base_local, repository, depth = 0)
@@ -190,14 +208,19 @@ module Lutaml
               part = derivation_part(type)
               return false unless part
 
-              next_local = part.base.to_s.split(":").last
+              raw_base = part.base.to_s
+              next_local = raw_base.split(":").last
               return true if next_local == base_local
+              return true if base_local == ANY_SIMPLE_TYPE_LOCAL &&
+                builtin_base?(raw_base)
 
               validly_derived?(
                 repository&.resolve_named_type(next_local),
                 base_local, repository, depth + 1
               )
             when Lutaml::Xml::Schema::Xsd::SimpleType
+              return true if base_local == ANY_SIMPLE_TYPE_LOCAL
+
               restriction = type.restriction
               return false unless restriction
 
@@ -231,6 +254,18 @@ module Lutaml
             end
           end
 
+          # Whether a derivation base attribute names a BUILTIN type —
+          # the xs:/xsd:-prefixed spellings only. An unresolvable
+          # UNPREFIXED base is a lenient-fallback miss, never a builtin
+          # (the string-fallback lesson).
+          #
+          # @param raw_base [String]
+          # @return [Boolean]
+          def builtin_base?(raw_base)
+            prefix = raw_base.to_s.split(":", 2).first
+            ValueSpace::BUILTIN_PREFIXES.include?(prefix)
+          end
+
           # XSD 1.0 §3.3.4 / §3.4.6: block on the element declaration
           # AND on the declared complexType forbids replacing the type
           # with one derived by the blocked kind. A type-less
@@ -241,15 +276,20 @@ module Lutaml
           # @return [Boolean]
           def override_blocked?(schema_element, override_type, repository)
             declared_local = schema_element.type.to_s.split(":").last
-            kind =
+            kinds =
               if declared_local.to_s.empty?
-                any_type_derivation_kind(override_type)
+                any_type_chain_kinds(override_type, repository)
               else
-                derivation_kind_from(override_type, declared_local) ||
-                  member_derivation_kind(override_type, declared_local,
-                                         repository)
+                direct = derivation_kind_from(override_type, declared_local)
+                direct ||= member_derivation_kind(override_type,
+                                                  declared_local,
+                                                  repository)
+                direct ||= derivation_chain_kinds(override_type,
+                                                  declared_local,
+                                                  repository).first
+                Array(direct)
               end
-            return false unless kind
+            return false if kinds.empty?
 
             tokens = effective_block_tokens(schema_element, repository)
             declared = repository&.resolve_named_type(declared_local)
@@ -261,7 +301,68 @@ module Lutaml
               tokens.intersect?(%w[extension restriction])
 
             blocked = tokens.include?("#all") ? %w[extension restriction] : tokens
-            blocked.include?(kind)
+            kinds.any? { |kind| blocked.include?(kind) }
+          end
+
+          # §3.3.4 clause 2.2.2: the block applies to the derivation
+          # IN WHOLE OR IN PART — the kinds of EVERY hop from the
+          # override down to the declared type (ctI's indirect shapes).
+          #
+          # @return [Array<String>]
+          def derivation_chain_kinds(type, declared_local, repository,
+                                     depth = 0)
+            return [] if type.nil? || declared_local.to_s.empty? || depth > 10
+
+            case type
+            when Lutaml::Xml::Schema::Xsd::ComplexType
+              part = derivation_part(type)
+              return [] unless part
+
+              kind = part.class.name.include?("Extension") ? "extension" : "restriction"
+              next_local = part.base.to_s.split(":").last
+              return [kind] if next_local == declared_local
+
+              [kind, *derivation_chain_kinds(
+                repository&.resolve_named_type(next_local), declared_local,
+                repository, depth + 1
+              )]
+            when Lutaml::Xml::Schema::Xsd::SimpleType
+              restriction = type.restriction
+              return [] unless restriction
+
+              next_local = restriction.base.to_s.split(":").last
+              return ["restriction"] if next_local == declared_local
+
+              derivation_chain_kinds(
+                repository&.resolve_named_type(next_local), declared_local,
+                repository, depth + 1
+              )
+            end
+          end
+
+          # Kinds along the override's whole chain down to the ur-type
+          # — a type-less declaration's block governs every hop
+          # (particlesIg003: ext extends base, base restricts anyType).
+          #
+          # @return [Array<String>]
+          def any_type_chain_kinds(type, repository, depth = 0)
+            return [] if type.nil? || depth > 10
+
+            if type.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType)
+              return ["restriction"]
+            end
+
+            part = derivation_part(type)
+            # A bare complexType (no derivation marker) restricts the
+            # ur-type per §3.4.3.
+            return ["restriction"] unless part
+
+            kind = part.class.name.include?("Extension") ? "extension" : "restriction"
+            next_local = part.base.to_s.split(":").last
+            [kind, *any_type_chain_kinds(
+              repository&.resolve_named_type(next_local), repository,
+              depth + 1
+            )]
           end
 
           # Derivation kind of an override against a type-less
@@ -418,6 +519,96 @@ module Lutaml
             "#{prefix}:#{local}"
           end
 
+          # XSD 1.0 §3.3.4 clause 2.2: a builtin override owes valid
+          # derivation from the declared type. anyType derives from
+          # nothing but itself; every other builtin derives from
+          # anySimpleType (§4.1.2 ancestry table); a named declared
+          # type must BE the builtin or one of its ancestors
+          # (stZ073b: xs:integer is no derivation of the
+          # restriction-of-union st.unionType); a declared UNION admits
+          # overrides naming a member or a builtin derived from one
+          # (the elemT071 rule, builtin members included).
+          #
+          # @return [Boolean]
+          def builtin_override_undervalued?(xml_element, schema_element,
+                                            repository)
+            override = xsi_type_name(xml_element).to_s
+            declared = declared_local_name(schema_element)
+            return false if declared.empty? || declared == override
+            return true if override == ANY_TYPE_LOCAL
+            return false if declared == ANY_SIMPLE_TYPE_LOCAL
+
+            covered = ValueSpace.builtin_derivation_cover(declared,
+                                                          override)
+            return !covered unless covered.nil?
+
+            declared_type = repository&.resolve_named_type(declared)
+            return false unless declared_type.is_a?(
+              Lutaml::Xml::Schema::Xsd::SimpleType,
+            )
+
+            if declared_type.union
+              return !union_member_covers_builtin?(declared_type, override,
+                                                   repository)
+            end
+
+            !validly_derived?(declared_type, override, repository)
+          end
+
+          # Whether the override builtin is admitted by a declared
+          # union: it names a member, or a member's chain reaches it.
+          #
+          # @return [Boolean]
+          def union_member_covers_builtin?(union_type, override, repository)
+            members = union_type.union.member_types.to_s.split(/\s+/)
+            members.any? do |member|
+              local = member.to_s.split(":").last
+              next true if local == override
+
+              member_type = repository&.resolve_named_type(local)
+              next false unless member_type
+
+              validly_derived?(member_type, override, repository)
+            end
+          end
+
+          # Handles an element whose xsi:type names a built-in: the
+          # §3.3.4 derivation gate, then builtin content validation.
+          #
+          # @return [Boolean] true when the element was handled
+          def builtin_override_handled?(xml_element, schema_element,
+                                        collector, repository)
+            if builtin_override_undervalued?(xml_element, schema_element,
+                                             repository)
+              report_error(
+                collector,
+                code: "xsi_type_not_derived",
+                message: "xsi:type '#{xsi_type_name(xml_element)}' is " \
+                         "not validly derived from the declared type " \
+                         "'#{declared_local_name(schema_element)}'",
+                location: xml_element.xpath,
+                context: { xsi_type: xsi_type_name(xml_element) },
+              )
+              return true
+            end
+
+            validate_builtin_type(xml_element,
+                                  builtin_override_reference(xml_element),
+                                  collector,
+                                  declared: schema_element,
+                                  repository: repository)
+            true
+          end
+
+          # The declared type's local name ('' when the declaration is
+          # type-less — the implicit anyType).
+          #
+          # @param schema_element [Object]
+          # @return [String]
+          def declared_local_name(schema_element)
+            schema_element.type.to_s.split(":").last.to_s
+          end
+
           # Resolve the type definition for an element
           #
           # @param schema_element [Lutaml::Xsd::Element, Lutaml::Xsd::ComplexType] Schema element
@@ -466,12 +657,17 @@ module Lutaml
           end
 
           # XSD 1.0 §3.3.3: a fixed value constrains the element — a
-          # non-empty lexical must equal it in the value space
+          # non-empty lexical must equal it in the VALUE space
           # (elemQ018). Empty content already validates against the
-          # fixed value through effective_text.
+          # fixed value through effective_text. Union/list-typed
+          # declarations map each lexical through the FIRST accepting
+          # member (§4.1.7) — 'true' equals fixed '1' as boolean-true
+          # (stE050), token collapse equates trailing blanks
+          # (stE065/066), float forms compare numerically (stE055).
           #
           # @return [void]
-          def validate_fixed_content(xml_element, declared, value, collector)
+          def validate_fixed_content(xml_element, declared, value, collector,
+                                     repository: nil)
             return unless declared.is_a?(Lutaml::Xml::Schema::Xsd::Element)
 
             fixed = declared.fixed.to_s
@@ -480,6 +676,8 @@ module Lutaml
 
             rule = declared_whitespace_rule(declared)
             return if canonical(value.to_s, rule) == canonical(fixed, rule)
+            return if fixed_value_space_equal?(declared, value.to_s, fixed,
+                                               repository)
 
             report_error(
               collector,
@@ -495,6 +693,76 @@ module Lutaml
             )
           end
 
+          # Value-space equality for union/list-typed declarations:
+          # each side keys through the first accepting member and the
+          # keys must match.
+          #
+          # @return [Boolean]
+          def fixed_value_space_equal?(declared, value, fixed, repository)
+            simple = declared.simple_type
+            return false unless simple
+
+            if simple.union
+              members = simple.union.member_types.to_s.split(/\s+/)
+              return union_keys_equal?(value, fixed, members, repository)
+            end
+            return false unless simple.list
+
+            item_union = inline_item_union(simple.list, repository)
+            return false unless item_union
+
+            left = value.split
+            right = fixed.split
+            return false unless left.size == right.size
+
+            left.zip(right).all? do |a, b|
+              union_keys_equal?(a, b, item_union, repository)
+            end
+          end
+
+          # The member_types array of a list's item type: an inline
+          # union, else the named union resolved through the
+          # repository.
+          #
+          # @return [Array, nil]
+          def inline_item_union(list, repository)
+            inline = Array(list.simple_type).first
+            return inline.union.member_types.to_s.split(/\s+/) if inline&.union
+
+            reference = list.item_type.to_s.split(":").last
+            named = repository&.resolve_named_type(reference)
+            return named.union.member_types.to_s.split(/\s+/) if
+              named.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType) && named.union
+
+            nil
+          end
+
+          # @return [Boolean]
+          def union_keys_equal?(value, fixed, members, repository)
+            a = first_member_key(value, members, repository)
+            b = first_member_key(fixed, members, repository)
+            !a.nil? && !b.nil? && a == b
+          end
+
+          # @return [Object, nil]
+          def first_member_key(lexical, members, repository)
+            members.each do |member|
+              local = member.to_s.split(":").last
+              key = ValueSpace.union_member_value_key(local, lexical)
+              return key unless key.nil?
+
+              named = repository&.resolve_named_type(local)
+              next unless named.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType) &&
+                named.union
+
+              nested = first_member_key(lexical,
+                                        named.union.member_types.to_s.split(/\s+/),
+                                        repository)
+              return nested unless nested.nil?
+            end
+            nil
+          end
+
           # @return [Symbol] :preserve, :replace or :collapse
           def declared_whitespace_rule(declared)
             reference = declared.type.to_s
@@ -543,7 +811,8 @@ module Lutaml
                                            collector, repository: nil,
                                            declared: nil)
             value = effective_text(xml_element, declared)
-            validate_fixed_content(xml_element, declared, value, collector)
+            validate_fixed_content(xml_element, declared, value, collector,
+                                   repository: repository)
 
             # Validate base type if present
             if simple_type.restriction
@@ -566,7 +835,8 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_complex_type_content(xml_element, complex_type,
-                                            collector, repository: nil)
+                                            collector, repository: nil,
+                                            declared: nil)
             # Complex type validation is handled by:
             # - AttributeValidationRule for attributes
             # - ContentModelValidationRule for content model
@@ -575,7 +845,8 @@ module Lutaml
             # Check for simple content
             if complex_type.simple_content
               validate_simple_content(xml_element, complex_type.simple_content,
-                                      collector, repository: repository)
+                                      collector, repository: repository,
+                                                 declared: declared)
             end
           end
 
@@ -1044,12 +1315,27 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_simple_content(xml_element, simple_content, collector,
-                                      repository: nil)
+                                      repository: nil, declared: nil)
             # Simple content means element has text content and attributes
             # Validate the text content as a simple type
             if simple_content.extension
-              # Extension adds attributes to a simple type
-              # Text content validation handled by base type
+              # The extension's TEXT still validates against the
+              # extension's base type — the extension itself only adds
+              # attributes (addB114: '62' violates base A's enumeration
+              # and range through E-A's simpleContent extension).
+              raw_base = simple_content.extension.base.to_s
+              base_local = raw_base.split(":").last
+              base_type = repository&.resolve_named_type(base_local)
+              if base_type.is_a?(Lutaml::Xml::Schema::Xsd::SimpleType)
+                validate_simple_type_content(xml_element, base_type,
+                                             collector,
+                                             repository: repository,
+                                             declared: declared)
+              elsif builtin_base?(raw_base)
+                validate_builtin_type(xml_element, raw_base, collector,
+                                      declared: declared,
+                                      repository: repository)
+              end
             elsif simple_content.restriction
               # Restriction constrains a simple type
               value = xml_element.text_content
@@ -1070,9 +1356,10 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_builtin_type(xml_element, type_name, collector,
-                                    declared: nil)
+                                    declared: nil, repository: nil)
             value = effective_text(xml_element, declared)
-            validate_fixed_content(xml_element, declared, value, collector)
+            validate_fixed_content(xml_element, declared, value, collector,
+                                   repository: repository)
             # A simple type has no element content: children under a
             # builtin-typed element are illegal even when the lexical
             # text is fine (dtZ86723 — the xsi:type-overridden root

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

@@ -66,6 +66,144 @@ module Lutaml
 
         BUILTIN_PREFIXES = %w[xs xsd].freeze
 
+        # The built-in type hierarchy (XSD 1.0 §4.1.2, Figure 4-1 +
+        # §3.14.6): each local name maps to its ANCESTOR builtins.
+        # A builtin xsi:type override is validly derived from a
+        # declared type only when the declared name is the override
+        # itself or one of its ancestors (§3.3.4 clause 2.2).
+        BUILTIN_ANCESTORS = {
+          "anyType" => [].freeze,
+          "anySimpleType" => %w[anyType].freeze,
+          "string" => %w[anySimpleType anyType].freeze,
+          "normalizedString" => %w[string anySimpleType anyType].freeze,
+          "token" => %w[normalizedString string anySimpleType anyType].freeze,
+          "language" => %w[token normalizedString string anySimpleType anyType].freeze,
+          "Name" => %w[token normalizedString string anySimpleType anyType].freeze,
+          "NCName" => %w[Name token normalizedString string anySimpleType anyType].freeze,
+          "ID" => %w[NCName Name token normalizedString string anySimpleType anyType].freeze,
+          "IDREF" => %w[NCName Name token normalizedString string anySimpleType anyType].freeze,
+          "NMTOKEN" => %w[token normalizedString string anySimpleType anyType].freeze,
+          "IDREFS" => %w[IDREF NCName Name token normalizedString string anySimpleType anyType].freeze,
+          "ENTITY" => %w[NCName Name token normalizedString string anySimpleType anyType].freeze,
+          "ENTITIES" => %w[ENTITY NCName Name token normalizedString string anySimpleType anyType].freeze,
+          "NMTOKENS" => %w[NMTOKEN token normalizedString string anySimpleType anyType].freeze,
+          "decimal" => %w[anySimpleType anyType].freeze,
+          "integer" => %w[decimal anySimpleType anyType].freeze,
+          "long" => %w[integer decimal anySimpleType anyType].freeze,
+          "int" => %w[long integer decimal anySimpleType anyType].freeze,
+          "short" => %w[int long integer decimal anySimpleType anyType].freeze,
+          "byte" => %w[short int long integer decimal anySimpleType anyType].freeze,
+          "nonNegativeInteger" => %w[integer decimal anySimpleType anyType].freeze,
+          "positiveInteger" => %w[nonNegativeInteger integer decimal anySimpleType anyType].freeze,
+          "unsignedLong" => %w[nonNegativeInteger integer decimal anySimpleType anyType].freeze,
+          "unsignedInt" => %w[unsignedLong nonNegativeInteger integer decimal anySimpleType anyType].freeze,
+          "unsignedShort" => %w[unsignedInt unsignedLong nonNegativeInteger integer decimal anySimpleType anyType].freeze,
+          "unsignedByte" => %w[unsignedShort unsignedInt unsignedLong nonNegativeInteger integer decimal anySimpleType anyType].freeze,
+          "nonPositiveInteger" => %w[integer decimal anySimpleType anyType].freeze,
+          "negativeInteger" => %w[nonPositiveInteger integer decimal anySimpleType anyType].freeze,
+          "float" => %w[anySimpleType anyType].freeze,
+          "double" => %w[anySimpleType anyType].freeze,
+          "duration" => %w[anySimpleType anyType].freeze,
+          "dateTime" => %w[anySimpleType anyType].freeze,
+          "time" => %w[anySimpleType anyType].freeze,
+          "date" => %w[anySimpleType anyType].freeze,
+          "gYear" => %w[anySimpleType anyType].freeze,
+          "gYearMonth" => %w[anySimpleType anyType].freeze,
+          "gMonth" => %w[anySimpleType anyType].freeze,
+          "gMonthDay" => %w[anySimpleType anyType].freeze,
+          "gDay" => %w[anySimpleType anyType].freeze,
+          "boolean" => %w[anySimpleType anyType].freeze,
+          "base64Binary" => %w[anySimpleType anyType].freeze,
+          "hexBinary" => %w[anySimpleType anyType].freeze,
+          "anyURI" => %w[anySimpleType anyType].freeze,
+          "QName" => %w[anySimpleType anyType].freeze,
+          "NOTATION" => %w[QName anySimpleType anyType].freeze,
+        }.freeze
+
+        # The VALUE-SPACE key of a lexical under a union member
+        # builtin — nil when the member does not accept the lexical.
+        # A union maps a lexical through its FIRST accepting member
+        # (§4.1.7), so 'true' and '1' are both boolean-true (stE050)
+        # and token collapse equates trailing blanks (stE065/066).
+        #
+        # @param local [String] builtin member local name
+        # @param value [String] the lexical
+        # @return [Object, nil] a comparable value, or nil
+        def self.union_member_value_key(local, value)
+          text = value.to_s
+          case local
+          when "boolean"
+            b = text.strip
+            return nil unless b.match?(/\A(?:true|false|1|0)\z/)
+
+            %w[true 1].include?(b)
+          when *INTEGER_TYPES
+            return nil unless integer_valid?(local, text)
+
+            Integer(text.strip)
+          when "float", "double"
+            return nil unless text.strip.match?(
+              /\A(?:[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|INF|-INF|NaN)\z/,
+            )
+
+            f = Float(text.strip)
+            f.nan? ? "nan" : f
+          when "decimal"
+            return nil unless text.strip.match?(
+              /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)\z/,
+            )
+
+            require "bigdecimal"
+            BigDecimal(text.strip)
+          when "string"
+            text
+          when "normalizedString"
+            text.gsub(/[\t\n\r]/, " ")
+          when *COLLAPSED_STRING_TYPES, "language", "Name", "NCName",
+            "ID", "IDREF", "NMTOKEN", "anyURI"
+            text.strip.split(/\s+/).join(" ")
+          when "gYear", "gYearMonth", "gMonth", "gMonthDay", "gDay"
+            return nil unless calendar_lexical_valid?(local, text)
+
+            calendar_key(text)
+          when "date", "dateTime", "time"
+            return nil unless lexical_answer(local, text) == true
+
+            temporal_key(text)
+          when "duration"
+            return nil unless duration_valid?(text)
+
+            duration_key(text)
+          when "hexBinary"
+            return nil unless text.match?(/\A(?:[0-9a-fA-F]{2})*\z/)
+
+            text.upcase
+          when "base64Binary"
+            return nil unless base64_valid?(text)
+
+            text
+          end
+        end
+
+        # Whether a builtin override local is validly derived from the
+        # declared local: identity or the declared name sits in the
+        # override's builtin ancestry. TRI-STATE: nil when the override
+        # is not a builtin local at all (the caller falls through to
+        # schema-type resolution). No `?` suffix — rubocop -A rewrites
+        # nil-returning predicate guards to false and breaks the
+        # contract.
+        #
+        # @param declared [String] declared type local name
+        # @param override [String] override builtin local name
+        # @return [Boolean, nil]
+        def self.builtin_derivation_cover(declared, override)
+          ancestors = BUILTIN_ANCESTORS[override.to_s]
+          return nil unless ancestors
+
+          declared.to_s == override.to_s ||
+            ancestors.include?(declared.to_s)
+        end
+
         # xsd:length counts list ITEMS for list types, not characters.
         LIST_BASES = %w[IDREFS ENTITIES NMTOKENS].freeze
 

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.113"
+    VERSION = "1.2.115"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.113
+  version: 1.2.115
 platform: ruby
 authors:
 - Ribose Inc.