lutaml-xsd 1.2.80 → 1.2.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aed69846e615ba0095fd9030ca3c7d870fe590c855694797393e669a57085ec
-  data.tar.gz: abcb15e8a7482e4589d08bbb886529f6aff6462db5c56e4626c9610dcb25777f
+  metadata.gz: 8c3da66790f16686077f84ff27947241c3fd9290e4a36f92d5b26ee70d340af4
+  data.tar.gz: 205af1e6a170523b054c34ba0cf43b86203877784bfe471ef88e47bcdbf60ae9
 SHA512:
-  metadata.gz: 928180700fa58c7965b7f57729b681a1580f18c5da136c6b7729a013426ca5bfeaad44b686ce0e28c2eb1247dd3e73ca1a1e34c81b61c37030165bf4f297ae62
-  data.tar.gz: 50441ce2cda522fed7e3df0acd8843ef3824a72b685bf663e21ade1d9c5a2366fbb2af244b4f83d839dbdb4e2c41faf3cf1eb14f3376bef8c0ef15f03de9fb98
+  metadata.gz: 6901b1b6a2fc09e00325fe3e24df146097e6bf6967493e46e04d7eabe8b7a9183cdccc2cc8ccf39cfd9d0f3cf90157b0647c772f61512a68085c041fbf1329be
+  data.tar.gz: 221ce2f9ce160b0524a99cb9dfb029ccc10040adbe8282e8cb37ecbc94cc9f689e1a6b2e28a6ca27cd069ef2c6547a5d728f37a3254b5fc501b9cce50d27118c

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4563/4696 (97.17%) |
+| pipeline | 4578/4696 (97.49%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -142,7 +142,8 @@ 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), +602 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), +617 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 +233,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%
@@ -422,6 +427,49 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   4569→4562 raw; 4563 with this round. NET -6 documented, not
   chased — the fixed-empty leg reverses the moment leptris-rs#25
   lands.
+- GROUP-CONTENT ROUND (2026-11-02): +13 (Group 8→0 — the family is
+  CLEAN at 126/126; Particles Db001/Db006 +2, Ea004/011/018 +3; suite
+  4563→4573 = 97.38% on the drifted stack, rspec green). FOUR Ruby
+  defects: (a) resolve_group scanned only top-level schemas — a group
+  declared in an IMPORTED document (the extension-body shape)
+  resolved to nothing (groupB009/010); nested resolved schemas are
+  now searched depth-guarded. (b) The NFA wiring missed the
+  lutaml-model container classes: a group whose declaration is xs:all
+  compiled ORDERED (groupO004), and with_occurrence gave min=0
+  particles one phantom extra copy (min=0/max=1 compiled capacity 2 —
+  masked for bare elements by the occurrence rule, visible wherever
+  nested group bounds lean on this verdict: groupJ003/J006/J008/L008
+  accepted forbidden repeats); a max=0 particle compiles to the empty
+  fragment (groupH008). (c) type_particles had no complexContent
+  restriction branch — a restriction body compiled EMPTY and children
+  passed unchecked (groupH008); a restriction replaces the base
+  content model. (d) The ref owner-namespace probe resolved ANY
+  declaration — including inline ones — so a qualified local namesake
+  hijacked unprefixed refs; the probe is GLOBAL-only (resolve_global),
+  the unprefixed ref canonically names a no-namespace declaration,
+  several distinct prefixed forms of one local name mean deliberate
+  disambiguation (no owner guess), and an unresolvable ref matches by
+  local name alone. KNOWN GAP left open: particlesQ032 — a
+  no-namespace document imported under an EXPLICIT namespace: its
+  globals must adopt the import namespace (MS-lenient chameleon
+  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).
 - 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/validation/content_model_matcher.rb

@@ -134,13 +134,13 @@ module Lutaml
 
         def compile_particle(particle)
           case particle
-          when Lutaml::Xsd::Sequence
+          when Lutaml::Xsd::Sequence, Lutaml::Xml::Schema::Xsd::Sequence
             compile_bounded_container(particle)
-          when Lutaml::Xsd::Choice
+          when Lutaml::Xsd::Choice, Lutaml::Xml::Schema::Xsd::Choice
             with_occurrence(particle) do
               compile_choice_particles(@container_particles.call(particle))
             end
-          when Lutaml::Xsd::All
+          when Lutaml::Xsd::All, Lutaml::Xml::Schema::Xsd::All
             # The all's own bounds wrap the member bitmask: an optional
             # all accepts the empty sequence even with mandatory
             # members (addB31).
@@ -181,10 +181,17 @@ module Lutaml
         end
 
         # A group ref expands to its declaration's container, whose own
-        # kind (sequence vs choice) decides the wiring.
+        # kind (sequence vs choice vs all) decides the wiring. Imported
+        # documents parse to the lutaml-model container classes —
+        # groupO004's xs:all compiled ORDERED before both All classes
+        # were wired to the bitmask.
         def compile_container_body(container)
-          if container.is_a?(Lutaml::Xsd::Choice)
+          if container.is_a?(Lutaml::Xsd::Choice) ||
+              container.is_a?(Lutaml::Xml::Schema::Xsd::Choice)
             compile_choice_particles(@container_particles.call(container))
+          elsif container.is_a?(Lutaml::Xsd::All) ||
+              container.is_a?(Lutaml::Xml::Schema::Xsd::All)
+            with_occurrence(container) { compile_all(container) }
           else
             compile_particles(@container_particles.call(container))
           end
@@ -235,14 +242,20 @@ module Lutaml
 
         # Wraps a body fragment with the particle's occurrence range:
         # min mandatory copies, then an unbounded loop on one extra copy
-        # or (max - min) optional copies.
+        # or (max - min) optional copies. The first body copy counts
+        # toward the bound: with min=0 it IS the first optional copy, so
+        # only max-1 more are wired (min=0/max=1 used to compile with
+        # capacity 2 — masked for bare elements by the occurrence rule,
+        # visible wherever nested group bounds lean on this verdict).
         def with_occurrence(particle)
           min = parse_occurs(particle.min_occurs, 1)
           max = parse_max_occurs(particle.max_occurs, 1)
-          eff_min = [min, MAX_UNROLL].min
+          return empty_fragment if max.is_a?(Integer) && max.zero?
+
           entry, exit_state = yield
           cursor = exit_state
           last_entry = entry
+          eff_min = [min, MAX_UNROLL].min
           (eff_min - 1).times do
             c_entry, c_exit = yield
             @epsilons[cursor] << c_entry
@@ -259,7 +272,8 @@ module Lutaml
             @epsilons[exit_state] << final
           else
             @epsilons[cursor] << final
-            (max - min).times do
+            optional = max - min - (min.zero? && max.is_a?(Integer) ? 1 : 0)
+            optional.times do
               c_entry, c_exit = yield
               @epsilons[cursor] << c_entry
               @epsilons[c_exit] << final

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,
@@ -224,9 +237,35 @@ module Lutaml
               attributes.concat(inherited_attributes(part.base, repository)) if part
             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.
           #
@@ -275,7 +314,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 +436,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 +483,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 +551,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 +590,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

@@ -299,6 +299,7 @@ module Lutaml
                 type.complex_content
               content = type.complex_content
               extension = Array(content.extension).first
+              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)
@@ -311,6 +312,14 @@ module Lutaml
                     particles << particle
                   end
                 end
+              elsif restriction
+                # A restriction REPLACES the base content model: only
+                # the restriction body's particles apply (groupH008's
+                # prohibited group ref was previously compiled as an
+                # EMPTY model and the children passed unchecked).
+                particles = COMPLEX_PARTICLE_KINDS.flat_map do |kind|
+                  Array(restriction.public_send(kind)).compact
+                end
               end
             end
 
@@ -508,12 +517,16 @@ module Lutaml
 
           # A qualified ref names a declaration in ONE namespace.
           # Global names duplicated across namespaces (import + main)
-          # resolve against the child's namespace today; when the owner
-          # schema's target namespace declares the same local name, a
-          # foreign child is an unexpected element (the engine — fed
-          # the documents one at a time — admits the substitute, so
-          # this runs on the engine-accept path). Wildcard territory
-          # is exempt.
+          # resolve against the child's namespace today; a foreign
+          # child is an unexpected element (the engine — fed the
+          # documents one at a time — admits the substitute, so this
+          # runs on the engine-accept path). Wildcard territory is
+          # exempt. The PREFIX is the signal: an unprefixed ref
+          # canonically names a NO-NAMESPACE declaration (Q016 — its
+          # qualified local namesake is irrelevant), a prefixed one
+          # names some namespace: a child in the opposite territory,
+          # or — for the duplicated-name shape — in any namespace but
+          # the owner's, cannot match.
           #
           # @return [void]
           def scan_cross_namespace_refs(xml_element, particles, collector,
@@ -526,12 +539,35 @@ module Lutaml
             end
             return if refs.empty?
 
+            # Several DISTINCT prefixed forms of one local name mean the
+            # schema disambiguates by prefix on purpose (particlesQ032:
+            # foo:e2 / x:e2 / bar:e2) — the owner-namespace guess is
+            # untenable there.
+            single_prefixed_form = refs.select do |r|
+              r.ref.to_s.include?(":")
+            end.group_by { |r| r.ref.to_s.split(":").last }
+              .select { |_, group| group.map { |r| r.ref.to_s.split(":").first }.uniq.size == 1 }
+              .map(&:first)
+
             xml_element.children.each do |child|
-              next if child.namespace_uri.to_s == owner_ns
-              next unless refs.any? do |r|
-                r.ref.to_s.split(":").last == child.name
+              child_ns = child.namespace_uri.to_s
+              next if child_ns == owner_ns
+
+              hit = refs.find do |r|
+                ref = r.ref.to_s
+                next false unless ref.split(":").last == child.name
+
+                if ref.include?(":")
+                  next false unless single_prefixed_form.include?(child.name)
+
+                  child_ns.empty? ||
+                    (child_ns != owner_ns &&
+                     repository.resolve_global(child.name, owner_ns))
+                else
+                  child_ns.match?(/\S/)
+                end
               end
-              next unless repository.resolve(child.name, owner_ns)
+              next unless hit
               next if wildcard_covers_child?(xml_element, particles, child,
                                              repository)
 
@@ -540,7 +576,7 @@ module Lutaml
                 code: "unexpected_element_in_sequence",
                 message: "Unexpected element '#{child.qualified_name}' " \
                          "in sequence — the reference names the same " \
-                         "declaration in #{owner_ns}",
+                         "declaration in another namespace",
                 location: child.xpath,
                 context: { element: child.qualified_name },
                 suggestion: "Use the declaration's namespace or rename " \
@@ -563,7 +599,7 @@ module Lutaml
             return nil unless repository
 
             local = particle.ref.to_s.split(":").last
-            (owner_ns && repository.resolve(local, owner_ns)) ||
+            (owner_ns && repository.resolve_global(local, owner_ns)) ||
               repository.resolve(local, child.namespace_uri) ||
               repository.resolve(local, nil)
           end

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

@@ -156,6 +156,27 @@ module Lutaml
           candidates.length == 1 ? candidates.first.first : nil
         end
 
+        # Global (top-level) element declaration only. A ref particle
+        # names a GLOBAL declaration; the index also holds inline ones,
+        # and a qualified local namesake must never satisfy the
+        # owner-namespace probe (particlesQ016: ref "foo" unprefixed vs
+        # the qualified local foo inside the restricted type).
+        #
+        # @param local_name [String]
+        # @param namespace_uri [String, nil]
+        # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
+        def resolve_global(local_name, namespace_uri)
+          return nil if local_name.nil? || local_name.empty?
+
+          candidates = @elements[local_name]
+          return nil if candidates.empty?
+
+          exact = candidates.find do |_element, namespace, kind|
+            kind == :top && namespace_matches?(namespace, namespace_uri)
+          end
+          exact&.first
+        end
+
         # Named type for an element's `type="prefix:Name"` reference.
         #
         # @param schema_element [Lutaml::Xml::Schema::Xsd::Element, nil]
@@ -386,7 +407,10 @@ module Lutaml
         end
 
         # Named group declaration by local name (for xs:group reference
-        # expansion in the content and occurrence walks).
+        # expansion in the content and occurrence walks). Group refs
+        # reach across imports (groupB009: an extension body references
+        # a group declared in the imported document), so nested
+        # resolved schemas are searched too.
         #
         # @param local_name [String]
         # @return [Lutaml::Xml::Schema::Xsd::Group, nil]
@@ -396,6 +420,25 @@ module Lutaml
           schemas.each do |schema|
             found = Array(schema.group).find { |g| g.name == local_name }
             return found if found
+
+            found = find_nested_group(local_name, schema)
+            return found if found
+          end
+          nil
+        end
+
+        # @return [Object, nil]
+        def find_nested_group(local_name, schema, depth = 0)
+          return nil if depth > 8
+
+          (Array(schema.include) + Array(schema.import)).each do |nested|
+            next unless nested.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
+
+            found = Array(nested.group).find { |g| g.name == local_name }
+            return found if found
+
+            found = find_nested_group(local_name, nested, depth + 1)
+            return found if found
           end
           nil
         end

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

@@ -252,12 +252,17 @@ module Lutaml
             # owner_ns nil means UNKNOWN (the caller has no owner
             # context), not "no namespace" — resolve(local, nil) only
             # matches no-namespace declarations, and a hint-loaded
-            # document can supply a foreign namesake.
+            # document can supply a foreign namesake. The owner probe
+            # is GLOBAL-only: a ref names a global declaration, and an
+            # inline namesake must not satisfy it.
             declaration =
-              (owner_ns && repository&.resolve(local, owner_ns)) ||
+              (owner_ns && repository&.resolve_global(local, owner_ns)) ||
               repository&.resolve(local, child.namespace_uri) ||
               repository&.resolve(local, nil)
-            return false unless declaration
+            # An unresolvable ref (particlesQ032: a no-namespace document
+            # imported under an explicit namespace — its globals index
+            # nowhere) is namespace-unconstrained: match by local name.
+            return child.name == local unless declaration
 
             child.name == declaration.name &&
               namespaces_match?(child.namespace_uri,

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.80"
+    VERSION = "1.2.82"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.80
+  version: 1.2.82
 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