lutaml-xsd 1.2.79 → 1.2.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc71d86940b282e842650b924ddfbef4c92dbb7d39645dec6e57cf80c5edbd81
-  data.tar.gz: e7643e86eb653d99ac2a72c39792b828994c1203a0fbbc89042856456ba59855
+  metadata.gz: 467b4c2343707af1d200289a1666d12e3ab984c438f0a29ef601d92143914562
+  data.tar.gz: d249de5b32c7fb201c8025cf56af088bde07acb6e1f76d2cd3ae1f15bd39cf29
 SHA512:
-  metadata.gz: 65b97ebeb74d183e3347e801b4d67fc183dec70698e501dd60fffcedcafbcc9a33f97d830aab3449a9ab72c8ca5ab0699aa41a5aafbbbd731512134408afcade
-  data.tar.gz: a4ae99c07f652e26102f6bae1f6a3d1c241d032436e2c424f4e03f06921b6feb0ef46798febf19598ec005fbbf6757829638c543e557ab399e6c2ffb785264b2
+  metadata.gz: 0f9c9c9c71bf3e064dd93ab6e007df3f9d90aaad2478bf77d8f7b7915804b5e8218a6d8adb97be02293560dc261ed957a6fe09af5404a30b18ee7a0d5d1a941e
+  data.tar.gz: 539a1503358510cde20356dc3d6a0a1a2c0b9daaebf77bda9ef45bc54f45222a0eaf2d97477b05f1347b1d35dcc22742963b0fc388823217bc6cd45ceb900bdf

data/TODO.conformance.md

@@ -120,22 +120,29 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4569/4696 (97.3%) |
+| pipeline | 4573/4696 (97.38%) |
 
-(2026-11-02, bundled-stack measurement on main with the escape,
+(2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
 engine-refresh, IC value-space, IC field-resolution, facade-silence,
 regex-semantics, redefine-refresh, gmonth-refresh, digit-vintage,
-stgh-refresh, group-ref, attribute-group-redefine and
-notation-length rounds; moxml
-0.6.1 (gemspec floor `~> 0.6.0` per the owner — the 0.6 line drops
-the Opal surface; measured conformance-neutral), lutaml-model
-0.8.155, engine leptris 1.9.401.0.) Same-stack comparison: 1.2.43
+stgh-refresh, group-ref, attribute-group-redefine,
+notation-length and ref-namespace rounds; moxml
+0.6.2 (gemspec floor `~> 0.6.0` per the owner — the 0.6 line drops
+the Opal surface), lutaml-model
+0.8.157 (gemspec floor `~> 0.8.156` per the owner; the lockfile is
+no longer committed — measurements resolve fresh), engine leptris
+1.9.402.0. The 1.9.402/0.6.2/0.8.157 ride costs 8 net: engine
+fixed+EMPTY content regressions (9 cases, filed leptris-rs#25 —
+empty content satisfies the fixed facet per §3.12.2/§4.3.1.2),
+reU6 we-accept, MINUS two drift fixes (RegexTest_234, stE063).)
+Same-stack comparison: 1.2.43
 baseline 3961 (84.3%) → 4039 (86.0%) → 4090 (87.1%) → 4360 (92.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%), +608 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+→ 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
+4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content round), +612 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
 \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
@@ -230,6 +237,8 @@ corners.
 | 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 |
+| 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 |
 
@@ -388,6 +397,59 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   duration/dateTime/gMonthDay/gYear corners (engine-bound and
   contested-highlight), gMonth_pattern001 (bugzilla 6901 — do not
   chase), double018 (disputed reading).
+- REF-NAMESPACE ROUND (2026-11-02): +2 Particles (13→11, particlesDb001/
+  Db006). A ref particle names a declaration in ONE namespace, but the
+  match path resolved it against the CHILD's namespace first — a global
+  declaration duplicated across an imported namespace satisfied the ref
+  and foreign substitutes were accepted. The ref branch now prefers the
+  declaration in the content-model OWNER schema's target namespace
+  (threaded through the match chain), then the child's, then the
+  unique-name fallback; parsed particles carry no prefix map
+  (lutaml-model discards xmlns), so the owner namespace is the
+  strongest signal available. The engine — fed documents one at a
+  time — admits the substitute, so a targeted scan on the engine-accept
+  path reports the foreign child (scan_cross_namespace_refs). NIL
+  owner namespace means UNKNOWN, not "no namespace": resolve(local,
+  nil) only matches no-namespace declarations and a hint-loaded
+  document can supply a foreign namesake (idH021 regression caught
+  and fixed in-round). Zero regressions on the drifted stack.
+- STACK DRIFT (2026-11-02, same day): the lockfile is no longer
+  committed (owner chore) — measurements resolve fresh and rode
+  moxml 0.6.1→0.6.2, leptris 1.9.401.0→1.9.402.0, lutaml-model
+  0.8.155→0.8.157 at once. TWO fixes rode in (RegexTest_234,
+  stE063); the fixed+EMPTY engine regression cost 9 (leptris-rs#25)
+  and reU6 flipped to we-accept (regex class, untriaged). Suite
+  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).
 - 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/content_model_validation_rule.rb

@@ -94,8 +94,9 @@ module Lutaml
 
             # The engine does not check abstract-element usage; scan for
             # it regardless of whether the engine answered.
+            owner_ns = repository&.target_namespace_for(schema_def)
             scan_abstract_usage(xml_element, particles, collector,
-                                repository)
+                                repository, owner_ns)
 
             handled = if occurrence_guard(repository).particles_safe?(particles)
                         engine_content_check(xml_element,
@@ -107,10 +108,14 @@ module Lutaml
                         # (particlesZ034_b); the Ruby matcher decides those.
                         false
                       end
-            return if handled
+            if handled
+              scan_cross_namespace_refs(xml_element, particles, collector,
+                                        repository, owner_ns)
+              return
+            end
 
             validate_particle_sequence(xml_element, particles, collector,
-                                       repository)
+                                       repository, owner_ns)
           end
 
           private
@@ -133,14 +138,14 @@ module Lutaml
           #
           # @return [void]
           def validate_particle_sequence(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns = nil)
             return if particles.empty?
 
             children = Array(xml_element.children)
             matcher = ContentModelMatcher.new(
               particles,
               element_match: ->(child, particle) do
-                element_matches?(child, particle, repository)
+                element_matches?(child, particle, repository, owner_ns)
               end,
               wildcard_match: ->(child, wildcard) do
                 wildcard_permits?(wildcard, xml_element, child, repository)
@@ -155,13 +160,13 @@ module Lutaml
             result = matcher.match(children)
             if result.matched
               scan_wildcard_strict_usage(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns)
               return
             end
 
             known = collector.errors.size
             walk_sequence_diagnostics(xml_element, particles, collector,
-                                      repository)
+                                      repository, owner_ns)
             return if collector.errors.size > known
 
             report_matcher_failure(result, children, xml_element, collector)
@@ -294,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)
@@ -306,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
 
@@ -317,15 +331,16 @@ module Lutaml
           # instances. Containers flatten to their leaf declarations —
           # the walk keeps them whole, the scan needs the leaves.
           def scan_abstract_usage(xml_element, particles, collector,
-                                  repository)
+                                  repository, owner_ns = nil)
             leaves = leaf_particles(particles, repository)
             xml_element.children.each do |child|
               leaves.each do |particle|
                 next unless particle.is_a?(Lutaml::Xsd::Element)
                 next unless particle_matches?(child, particle, repository,
-                                              parent: xml_element)
+                                              parent: xml_element,
+                                              owner_ns: owner_ns)
                 next unless element_declaration_abstract?(particle, child,
-                                                          repository)
+                                                          repository, owner_ns)
 
                 report_error(
                   collector,
@@ -360,7 +375,7 @@ module Lutaml
           #
           # @return [void]
           def scan_wildcard_strict_usage(xml_element, particles, collector,
-                                         repository)
+                                         repository, owner_ns = nil)
             leaves = leaf_particles(particles, repository)
             wildcards = leaves.select { |p| p.is_a?(Lutaml::Xsd::Any) }
             return if wildcards.empty?
@@ -370,7 +385,7 @@ module Lutaml
             end
             xml_element.children.each do |child|
               next if element_leaves.any? do |p|
-                element_matches?(child, p, repository)
+                element_matches?(child, p, repository, owner_ns)
               end
 
               wildcards.each do |wildcard|
@@ -391,7 +406,7 @@ module Lutaml
           #
           # @return [void]
           def walk_sequence_diagnostics(xml_element, particles, collector,
-                                         repository)
+                                        repository, owner_ns = nil)
             return if particles.empty?
 
             children = xml_element.children
@@ -418,13 +433,15 @@ module Lutaml
                 child = children[child_index]
 
                 break unless particle_matches?(child, particle, repository,
-                                               parent: xml_element)
+                                               parent: xml_element,
+                                               owner_ns: owner_ns)
 
                 if particle.is_a?(Lutaml::Xsd::Any)
                   check_strict_wildcard_child(child, particle, collector,
                                               repository)
                 elsif particle.is_a?(Lutaml::Xsd::Element) &&
-                    element_declaration_abstract?(particle, child, repository)
+                    element_declaration_abstract?(particle, child, repository,
+                                                  owner_ns)
                   report_error(
                     collector,
                     code: "abstract_element_used",
@@ -489,19 +506,101 @@ module Lutaml
           # declarations cannot appear directly in instances (substitution
           # members remain legal). Direct declarations carry their own
           # abstract flag; references resolve to the global declaration.
-          def element_declaration_abstract?(particle, child, repository)
-            declaration = declaration_for(particle, child, repository)
+          def element_declaration_abstract?(particle, child, repository,
+                                            owner_ns = nil)
+            declaration = declaration_for(particle, child, repository,
+                                          owner_ns)
             return false unless declaration
 
             truthy?(declaration.abstract) && child.name == declaration.name
           end
 
-          def declaration_for(particle, child, repository)
+          # A qualified ref names a declaration in ONE namespace.
+          # Global names duplicated across namespaces (import + main)
+          # 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,
+                                        repository, owner_ns)
+            return if owner_ns.nil?
+
+            refs = leaf_particles(particles, repository).select do |p|
+              p.is_a?(Lutaml::Xml::Schema::Xsd::Element) &&
+                p.ref.to_s.match?(/\S/)
+            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|
+              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 hit
+              next if wildcard_covers_child?(xml_element, particles, child,
+                                             repository)
+
+              report_error(
+                collector,
+                code: "unexpected_element_in_sequence",
+                message: "Unexpected element '#{child.qualified_name}' " \
+                         "in sequence — the reference names the same " \
+                         "declaration in another namespace",
+                location: child.xpath,
+                context: { element: child.qualified_name },
+                suggestion: "Use the declaration's namespace or rename " \
+                            "the duplicate",
+              )
+            end
+          end
+
+          def wildcard_covers_child?(xml_element, particles, child,
+                                     repository)
+            leaf_particles(particles, repository).any? do |p|
+              next false unless p.is_a?(Lutaml::Xsd::Any)
+
+              wildcard_permits?(p, xml_element, child, repository)
+            end
+          end
+
+          def declaration_for(particle, child, repository, owner_ns = nil)
             return particle if particle.name.to_s.match?(/\S/)
             return nil unless repository
 
             local = particle.ref.to_s.split(":").last
-            repository.resolve(local, child.namespace_uri) ||
+            (owner_ns && repository.resolve_global(local, owner_ns)) ||
+              repository.resolve(local, child.namespace_uri) ||
               repository.resolve(local, nil)
           end
 
@@ -649,10 +748,11 @@ module Lutaml
           #   wildcard namespace constraints scoped to the target namespace
           # @return [Boolean]
           def particle_matches?(xml_element, particle, repository = nil,
-                                parent: nil, group_depth: 0)
+                                parent: nil, group_depth: 0, owner_ns: nil)
             particle_matches_child?(xml_element, particle, repository,
                                     parent: parent,
-                                    group_depth: group_depth)
+                                    group_depth: group_depth,
+                                    owner_ns: owner_ns)
           end
 
           # Check if XML element matches schema element.
@@ -663,9 +763,10 @@ module Lutaml
           # @param schema_element [Lutaml::Xsd::Element] The schema element
           # @param repository [SchemaDefinitionResolver, nil]
           # @return [Boolean]
-          def element_matches?(xml_element, schema_element, repository = nil)
+          def element_matches?(xml_element, schema_element, repository = nil,
+                               owner_ns = nil)
             particle_matches_declaration?(xml_element, schema_element,
-                                          repository) ||
+                                          repository, owner_ns) ||
               substitution_member?(xml_element, schema_element, repository)
           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

@@ -227,14 +227,18 @@ module Lutaml
 
         # Whether an instance child matches a content-model particle.
         # Direct declarations compare name and expected namespace; ref
-        # particles take the name and namespace of the global declaration
-        # they reference, resolved against the child's namespace.
+        # particles name a qualified declaration — the owner schema's
+        # target namespace is preferred, then the child's, then the
+        # unique-name fallback (parsed particles carry no prefix map).
         #
         # @param child [XmlElement]
         # @param particle [Lutaml::Xsd::Element]
         # @param repository [SchemaDefinitionResolver, nil]
+        # @param owner_ns [String, nil] target namespace of the schema
+        #   owning the content model
         # @return [Boolean]
-        def particle_matches_declaration?(child, particle, repository)
+        def particle_matches_declaration?(child, particle, repository,
+                                          owner_ns = nil)
           ref = particle.ref.to_s
           if ref.empty?
             name = particle.name.to_s
@@ -245,9 +249,20 @@ module Lutaml
                                                          repository))
           else
             local = ref.split(":").last
-            declaration = repository&.resolve(local, child.namespace_uri) ||
+            # 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. 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_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,
@@ -413,10 +428,12 @@ module Lutaml
         # @param group_depth [Integer] recursion guard for group refs
         # @return [Boolean]
         def particle_matches_child?(child, particle, repository,
-                                    parent: nil, group_depth: 0)
+                                    parent: nil, group_depth: 0,
+                                    owner_ns: nil)
           case particle
           when Lutaml::Xsd::Element
-            particle_matches_declaration?(child, particle, repository) ||
+            particle_matches_declaration?(child, particle, repository,
+                                          owner_ns) ||
               substitution_member?(child, particle, repository)
           when Lutaml::Xsd::Any
             wildcard_permits?(particle, parent || child, child, repository)
@@ -425,13 +442,15 @@ module Lutaml
                                    group_depth).any? do |container|
               particle_matches_child?(child, container, repository,
                                       parent: parent,
-                                      group_depth: group_depth + 1)
+                                      group_depth: group_depth + 1,
+                                      owner_ns: owner_ns)
             end
           when Lutaml::Xsd::Sequence, Lutaml::Xsd::Choice, Lutaml::Xsd::All
             collect_content_particles(particle).any? do |leaf|
               particle_matches_child?(child, leaf, repository,
                                       parent: parent,
-                                      group_depth: group_depth)
+                                      group_depth: group_depth,
+                                      owner_ns: owner_ns)
             end
           else
             false

data/lib/lutaml/xsd/version.rb

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

metadata

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