lutaml-xsd 1.2.112 → 1.2.114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdfdd257c5d78df578d997d512d39f17f9c83b10d4a8928708767b41bb6224b9
-  data.tar.gz: c9a0bc6226dd8346324c44af5f93906f851b477895b145ed86a89cc2a70f8538
+  metadata.gz: 36f7c7c0e9d599f7400dac905f372692d9da5d253bd5d67069106d923259a4b3
+  data.tar.gz: 6a2b5a3b8f8db1067381b3e8f924da0f06af636a152626795167b97012510e40
 SHA512:
-  metadata.gz: f503a443b9e205299c93eadd6c4f878f8fe025a2d0bd0514629fcdd38945f533b948afa656aa3e57bd8b5bfc2ade4213f9c77380d5bcc395c279a23b247c1da6
-  data.tar.gz: 1f533117654e06d3e2acde45f3c053eb99c9c41030b9a844fa598482372db23e24029fe3eaf7514ce7033c8a4c94b9bcd11b62209d00e7ab0b56ccc9458e6e66
+  metadata.gz: c9467308b09e8249e3e5b87a1b1a2d298f95d55ec4bf466a63a0a376752e813f0f9753b821d25c000e3d39a0c65249e675df39ec1496f47ecadde12b5782d28d
+  data.tar.gz: f147cc2f3ebb9d6ec7ca62601b72573ccc70433bdd36b50cbe46133e815b052ac5a4fec48153e3e2823ab8c6d1f3955f13f1f1714b761b4bfc1310de174b5c20

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4644/4696 measured + 5 budget exclusions (98.96% of measured) |
+| pipeline | 4658/4696 (99.19%) — first measure above 99 |
 
 (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), +683 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), +697 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
@@ -612,6 +612,78 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   the RAW validity boolean — expected-INVALID rows reading false
   are PASSES; the first assembly inverted them and manufactured 9
   phantom reZ regressions before the correction.
+- QUADRATIC-DISPATCH ROUND (2026-11-12, release pending): the
+  per-rule profile on reZ003v (a trivial `[\w]` pattern over a
+  232KB instance of ~65k `<value>` siblings) showed the RULES at
+  ~3.3s and the DISPATCH at ~100-370s — `same_name_sibling_index`
+  scanned the parent's raw children per element (O(N) per child,
+  O(N²) per parent) TIMES five category walks, and
+  `positional_children` re-walked the parent's particle tree per
+  element. THREE cuts, all semantics-preserving: (a) the sibling
+  ordinal is now a per-parent identity-keyed map built in ONE
+  O(N) pass (running same-name count — identical to the old
+  take(position).count reading); (b) the dispatch skips the scan
+  when the content model holds at most ONE same-named candidate
+  (positional binding only matters for DUPLICATE declarations,
+  isDefault079); (c) positional_children memoizes per
+  (declaration, name) on the resolver (schema immutable once
+  indexed). reZ003v validate 373.6s → 2.94s (127×); rspec 1663
+  green and 40s faster; rubocop clean. LEDGER: 4649/4696
+  (98.91%) — the FIRST FULL-DENOMINATOR MEASURE of the campaign:
+  ALL 94 batches completed in one rake run, the 5 reZ budget
+  exclusions RETIRED (reZ003v/005v/005i/006v/006i measured and
+  PASSING in-run), and the batch-03000 carry-over convention
+  RETIRED (reI003's tax was the same dispatch overhead, not regex
+  backtracking — 50/50 fresh). ZERO regressions vs the 1.2.112
+  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).
 - 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/rule_engine.rb

@@ -80,8 +80,17 @@ module Lutaml
                 resolver.resolve(parent.name, parent.namespace_uri)
               candidates = resolver.positional_children(parent_declaration,
                                                         xml_element.name)
-              positional = candidates[same_name_sibling_index(xml_element,
-                                                              parent)]
+              # The scan only matters when the parent's content model
+              # holds DUPLICATE same-named declarations (isDefault079);
+              # a sole candidate binds regardless of position — skipping
+              # the sibling scan keeps wide documents linear.
+              positional = if candidates.size > 1
+                             candidates[same_name_sibling_index(
+                               xml_element, parent
+                             )]
+                           else
+                             candidates.first
+                           end
               # The binding must agree with the child's OWN namespace:
               # an unqualified ref's global namesake never serves a
               # qualified local namesake (particlesQ016).
@@ -245,21 +254,31 @@ module Lutaml
           override && override.value.to_s.split(":").last
         end
 
-        # The child's position among its same-named siblings — the index
+        # The child's ordinal among its same-named siblings — the index
         # the positional binding (duplicate same-named declarations,
-        # isDefault079) binds to. Computed on the RAW moxml nodes: the
+        # isDefault079) binds to. Keyed on the RAW moxml nodes: the
         # wrapper objects are not identity-stable across accessor calls
-        # (the IdUniquenessRule lesson).
+        # (the IdUniquenessRule lesson). The per-parent ordinal map is
+        # memoized — a document of N same-named siblings costs one
+        # O(N) pass per parent instead of an O(N) scan per child
+        # (reZ003v: 65k siblings made every dispatch quadratic, times
+        # five category walks).
         #
         # @return [Integer]
         def same_name_sibling_index(element, parent)
-          raw_children = Array(parent.moxml_element.elements)
-          position = raw_children.index do |node|
-            node.equal?(element.moxml_element)
+          parent_raw = parent.moxml_element
+          cache = (@sibling_ordinals ||= {}.compare_by_identity)
+          ordinals = cache[parent_raw]
+          if ordinals.nil?
+            ordinals = {}.compare_by_identity
+            counts = Hash.new(0)
+            parent_raw.elements.each do |node|
+              ordinals[node] = counts[node.name]
+              counts[node.name] += 1
+            end
+            cache[parent_raw] = ordinals
           end
-          return 0 if position.nil?
-
-          raw_children.take(position).count { |node| node.name == element.name }
+          ordinals.fetch(element.moxml_element, 0)
         end
 
         # Whether the parent's content model holds a processContents

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,
@@ -136,7 +144,9 @@ module Lutaml
               # 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)
+              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,
@@ -172,7 +182,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 +205,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 +251,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 +273,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 +298,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 +516,95 @@ 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 = Array(union_type.union.member_types)
+            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)
+            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
@@ -566,7 +753,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 +763,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 +1233,26 @@ 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)
+              end
             elsif simple_content.restriction
               # Restriction constrains a simple type
               value = xml_element.text_content

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

@@ -607,17 +607,28 @@ module Lutaml
         # @param parent_declaration [Lutaml::Xml::Schema::Xsd::Element, nil]
         # @param local_name [String]
         # @return [Array<Lutaml::Xml::Schema::Xsd::Element>]
+        #
+        # Memoized per (declaration, local name): the dispatch calls
+        # this for every element, and the particle-tree walk cost is
+        # constant across elements of the same parent type (the schema
+        # is immutable once indexed).
         def positional_children(parent_declaration, local_name)
+          key = [parent_declaration.object_id, local_name]
+          cache = (@positional_children ||= {})
+          cached = cache[key]
+          return cached if cached
+
           type = parent_declaration&.complex_type ||
             resolve_type(parent_declaration)
-          return [] unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
-
-          particles = []
-          collect_named_particles(particle_for_type(type), local_name,
-                                  particles, {}.compare_by_identity, 0)
-          return [] unless particles.all? { |p| @namespaces.key?(p) }
-
-          particles
+          computed = []
+          if type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+            particles = []
+            collect_named_particles(particle_for_type(type), local_name,
+                                    particles, {}.compare_by_identity, 0)
+            computed = particles if particles.all? { |p| @namespaces.key?(p) }
+          end
+          cache[key] = computed
+          computed
         end
 
         private

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

@@ -66,6 +66,79 @@ 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
+
+        # 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.112"
+    VERSION = "1.2.114"
   end
 end

metadata

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