cataract 0.4.0 → 0.5.0

data/ext/cataract/specificity.c

@@ -13,6 +13,8 @@
  *   - :not() doesn't count itself, but its content does
  *   - Legacy pseudo-elements with single colon (:before) count as pseudo-elements
  *   - Universal selector (*) has zero specificity
+ *   - A namespace prefix (ns|E, *|E, |E) contributes zero itself - only the
+ *     local name after '|' counts, same as a bare "E" would
  */
 
 #include "cataract.h"
@@ -188,14 +190,23 @@ VALUE calculate_specificity(VALUE self, VALUE selector_string) {
             continue;
         }
 
-        // Type selector (element name): div, span, etc.
+        // Type selector (element name): div, span, etc. - or a namespace
+        // prefix (css-namespaces-3 qname grammar: prefix? '|' ident). A
+        // prefix contributes nothing itself; only the local name after '|'
+        // is the real type selector, so don't count it here - just skip
+        // past it and the separator and let the next iteration count the
+        // local name instead.
         if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) {
-            element_count++;
             // Skip the identifier
             while (p < pe && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
                               (*p >= '0' && *p <= '9') || *p == '-' || *p == '_')) {
                 p++;
             }
+            if (p < pe && *p == '|') {
+                p++; // skip namespace separator - prefix itself doesn't count
+                continue;
+            }
+            element_count++;
             continue;
         }
 

data/lib/cataract/at_rule.rb

@@ -8,7 +8,6 @@ module Cataract
   # The content field varies by at-rule type:
   # - `@keyframes`: Array of Rule (keyframe percentage blocks like "0%", "100%")
   # - `@font-face`: Array of Declaration (font property declarations)
-  # - `@supports`: Array of Rule (conditional rules)
   #
   # @example Parse @keyframes
   #   css = "@keyframes fade { 0% { opacity: 0; } 100% { opacity: 1; } }"
@@ -29,7 +28,10 @@ module Cataract
   # @attr [Array<Rule>, Array<Declaration>] content Nested rules or declarations
   # @attr [nil] specificity Always nil for at-rules (they don't have CSS specificity)
   # @attr [Integer, nil] media_query_id ID of MediaQuery if inside @media block, nil otherwise
-  AtRule = Struct.new(:id, :selector, :content, :specificity, :media_query_id) unless const_defined?(:AtRule)
+  # @attr [Integer, nil] conditional_group_id ID of ConditionalGroup if inside @supports/@layer/@container/@scope, nil otherwise
+  unless const_defined?(:AtRule)
+    AtRule = Struct.new(:id, :selector, :content, :specificity, :media_query_id, :conditional_group_id)
+  end
 
   class AtRule
     # Check if this is a selector-based rule (vs an at-rule like @keyframes).

data/lib/cataract/conditional_group.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Cataract
+  # ConditionalGroup represents a CSS "conditional group" at-rule wrapper -
+  # @supports, @layer, @container, or @scope.
+  #
+  # Like MediaQuery, these are stored in the Stylesheet and referenced by
+  # Rules/AtRules via conditional_group_id, so the rules they wrap stay flat
+  # and queryable in Stylesheet#rules while the wrapper's own name/condition
+  # (and nesting inside other conditional groups, via parent_id) survive for
+  # round-trip serialization. Cataract never evaluates the condition/name
+  # (no feature-query or container-query matching) - it's kept as opaque
+  # text.
+  #
+  # @example Access conditional-group properties
+  #   group = ConditionalGroup.new(0, :supports, nil, '(display: grid)', nil)
+  #   group.id #=> 0
+  #   group.type #=> :supports
+  #   group.condition #=> "(display: grid)"
+  #
+  # @attr [Integer] id Unique identifier for this conditional group within the stylesheet
+  # @attr [Symbol] type At-rule kind (:supports, :layer, :container, :scope)
+  # @attr [String, nil] name Named form (e.g. `@layer utilities`, `@container sidebar`), nil if unnamed
+  # @attr [String, nil] condition Opaque condition/prelude text (feature query, container query, scope root/limit), nil if none
+  # @attr [Integer, nil] parent_id Id of the enclosing ConditionalGroup, or nil if not nested inside another one
+  ConditionalGroup = Struct.new(:id, :type, :name, :condition, :parent_id) do
+    # Create a ConditionalGroup with keyword arguments for readability.
+    #
+    # @param id [Integer] Unique ID for this conditional group
+    # @param type [Symbol] At-rule kind (:supports, :layer, :container, :scope)
+    # @param name [String, nil] Named form, if any
+    # @param condition [String, nil] Opaque condition/prelude text, if any
+    # @param parent_id [Integer, nil] Enclosing ConditionalGroup's id, if nested
+    # @return [ConditionalGroup] New conditional group instance
+    #
+    # @example
+    #   ConditionalGroup.make(id: 0, type: :supports, condition: '(display: grid)')
+    def self.make(id:, type:, name: nil, condition: nil, parent_id: nil)
+      new(id, type, name, condition, parent_id)
+    end
+
+    # Compare conditional groups for equality based on type, name, condition,
+    # and nesting. IDs are not considered since they're internal identifiers.
+    #
+    # @param other [Object] Object to compare with
+    # @return [Boolean] true if conditional groups match
+    def ==(other)
+      case other
+      when ConditionalGroup
+        type == other.type && name == other.name && condition == other.condition
+      else
+        false
+      end
+    end
+    alias_method :eql?, :==
+
+    # Generate hash code for this conditional group.
+    #
+    # @return [Integer] hash code
+    def hash
+      [self.class, type, name, condition].hash
+    end
+
+    # Get detailed inspection string.
+    #
+    # @return [String] Inspection string
+    def inspect
+      "#<ConditionalGroup id=#{id} type=#{type.inspect} name=#{name.inspect} " \
+        "condition=#{condition.inspect} parent_id=#{parent_id.inspect}>"
+    end
+  end
+end

data/lib/cataract/native.rb

@@ -19,6 +19,7 @@ require_relative 'declaration'
 require_relative 'rule'
 require_relative 'at_rule'
 require_relative 'media_query'
+require_relative 'conditional_group'
 require_relative 'import_statement'
 
 require_relative 'native_extension'

data/lib/cataract/pure/flatten.rb

@@ -438,6 +438,11 @@ module Cataract
           # All rules being merged have the same media_query_id (they were grouped by it)
           media_query_id = rules.first.media_query_id
 
+          # Extract conditional_group_id from first rule in group (mirrors
+          # media_query_id above - not part of the grouping key, but should
+          # be uniform in practice for any group actually worth merging)
+          conditional_group_id = rules.first.conditional_group_id
+
           # Create merged rule
           Rule.new(
             0, # ID will be updated later
@@ -447,7 +452,8 @@ module Cataract
             nil,  # No parent after flattening
             nil,  # No nesting style after flattening
             selector_list_id, # Preserve if all rules share same ID
-            media_query_id # Preserve media context
+            media_query_id, # Preserve media context
+            conditional_group_id # Preserve conditional-group context
           )
         end
 

data/lib/cataract/pure/parser.rb

@@ -61,7 +61,8 @@ module Cataract
           true
         end
 
-        def initialize(css_string, parser_options: {}, parent_media_sym: nil, parent_media_query_id: nil, depth: 0)
+        def initialize(css_string, parser_options: {}, parent_media_sym: nil, parent_media_query_id: nil,
+                       parent_conditional_group_id: nil, depth: 0)
           # Type validation
           raise TypeError, "css_string must be a String, got #{css_string.class}" unless css_string.is_a?(String)
 
@@ -71,6 +72,7 @@ module Cataract
           @_len = @_css.bytesize
           @_parent_media_sym = parent_media_sym
           @_parent_media_query_id = parent_media_query_id
+          @_parent_conditional_group_id = parent_conditional_group_id
           @_depth = depth # Current recursion depth (passed from parent parser)
 
           # Private: Parser options with defaults
@@ -120,6 +122,7 @@ module Cataract
           @_media_query_id_counter = 0   # Next MediaQuery ID (0-indexed)
           @_next_selector_list_id = 0    # Counter for selector list IDs
           @_next_media_query_list_id = 0 # Counter for media query list IDs
+          @_conditional_group_id_counter = 0 # Next ConditionalGroup ID (0-indexed)
           @_rule_id_counter = 0          # Next rule ID (0-indexed)
           @_media_query_count = 0        # Safety limit
 
@@ -127,6 +130,7 @@ module Cataract
           @rules = []                    # Flat array of Rule structs
           @media_queries = []            # Array of MediaQuery objects
           @media_index = {}              # Symbol => Array of rule IDs (for backwards compat/caching)
+          @conditional_groups = []       # Array of ConditionalGroup objects (@supports/@layer/@container/@scope)
           @imports = []                  # Array of ImportStatement structs
           @charset = nil                 # @charset declaration
 
@@ -261,6 +265,7 @@ module Cataract
             media_queries: @media_queries,
             _selector_lists: @_selector_lists,
             _media_query_lists: @_media_query_lists,
+            conditional_groups: @conditional_groups,
             imports: @imports,
             charset: @charset,
             _has_nesting: @_has_nesting
@@ -743,7 +748,8 @@ module Cataract
                 parent_rule_id,
                 nil,  # nesting_style (nil for @media nesting)
                 nil,  # selector_list_id
-                nested_media_query_id # media_query_id
+                nested_media_query_id, # media_query_id
+                @_parent_conditional_group_id # conditional_group_id (inherited, not created here)
               )
 
               # Mark that we have nesting
@@ -1035,17 +1041,53 @@ module Cataract
           @_has_nesting ||= nested_result[:_has_nesting] # rubocop:disable Naming/MemoizedInstanceVariableName -- not memoization, propagating a flag from the nested parse
         end
 
+        # Merge nested ConditionalGroup objects into @conditional_groups,
+        # renumbering ids and rebasing each one's own parent_id.
+        #
+        # A group's parent_id is either (a) another group ALSO present in
+        # nested_result[:conditional_groups] - a local sibling created within
+        # the same nested Parser, needing the same renumbering - or (b) the
+        # external parent context that was passed into that nested Parser's
+        # constructor, which already refers to a real id in THIS parser's own
+        # numbering scheme and must NOT be touched. Both a local sibling's id
+        # and the external context can be small, overlapping numbers (each
+        # fresh Parser instance's own ids start at 0), so this is resolved by
+        # membership in old_to_new (built as we go, since parents are always
+        # discovered before their children) rather than by comparing values.
+        #
+        # @param nested_result [Hash] Result hash from a nested Parser#parse call
+        # @return [Hash{Integer => Integer}] old (local) id => new (merged) id,
+        #   for callers to also remap rules' conditional_group_id with
+        def merge_nested_conditional_groups(nested_result)
+          old_to_new = {}
+          return old_to_new unless nested_result[:conditional_groups] && !nested_result[:conditional_groups].empty?
+
+          nested_result[:conditional_groups].each do |group|
+            new_id = @_conditional_group_id_counter
+            new_parent_id = old_to_new.key?(group.parent_id) ? old_to_new[group.parent_id] : group.parent_id
+            old_to_new[group.id] = new_id
+            @conditional_groups << Cataract::ConditionalGroup.new(new_id, group.type, group.name, group.condition, new_parent_id)
+            @_conditional_group_id_counter += 1
+          end
+
+          old_to_new
+        end
+
         # Parse at-rule (@media, @supports, @charset, @keyframes, @font-face, etc)
         # Translated from C: see ext/cataract/css_parser.c lines 962-1128
         def parse_at_rule
           at_rule_start = @_pos # Points to '@'
           @_pos += 1 # skip '@'
 
-          # Find end of at-rule name (stop at whitespace or opening brace)
+          # Find end of at-rule name (stop at whitespace, '{', '(', ';', or a
+          # quote - an ident naturally terminates at any of these even with
+          # no space, e.g. minified "@supports(display:grid){" or
+          # "@media(...){" or "@namespace"http://...";)
           name_start = @_pos
           until eof?
             byte = peek_byte
-            break if whitespace?(byte) || byte == BYTE_LBRACE
+            break if whitespace?(byte) || byte == BYTE_LBRACE || byte == BYTE_LPAREN || byte == BYTE_SEMICOLON ||
+                     byte == BYTE_DQUOTE || byte == BYTE_SQUOTE
 
             @_pos += 1
           end
@@ -1058,9 +1100,14 @@ module Cataract
           # Handle @import - must come before rules (except @charset)
           return parse_import_at_rule if at_rule_name == 'import'
 
+          # Handle @namespace - purely a statement (never a block), so it's
+          # handled here rather than falling through to the conditional-group
+          # or unknown-at-rule paths below.
+          return parse_namespace_at_rule(at_rule_start) if at_rule_name == 'namespace'
+
           # Handle conditional group at-rules: @supports, @layer, @container, @scope
           # These behave like @media but don't affect media context
-          return parse_conditional_group_at_rule(at_rule_name) if AT_RULE_TYPES.include?(at_rule_name)
+          return parse_conditional_group_at_rule(at_rule_name, at_rule_start) if AT_RULE_TYPES.include?(at_rule_name)
 
           # Handle @media specially - parse content and track in media_index
           return parse_media_at_rule if at_rule_name == 'media'
@@ -1114,35 +1161,137 @@ module Cataract
           parse_import_statement
         end
 
+        # @namespace [prefix] (url(...) | "..."); - declares a namespace
+        # prefix (or, with no prefix, the default namespace) mapped to a
+        # URI. Per css-namespaces-3 this is purely a statement - it never
+        # has a block - so, like @layer's statement form, it's captured
+        # verbatim as an AtRule with content nil rather than needing any
+        # dedicated struct. Multiple @namespace rules are legal (one
+        # default + any number of prefixed ones); nothing here computes
+        # resolution between them, callers read the prefix/URI back out of
+        # the raw text.
+        def parse_namespace_at_rule(at_rule_start)
+          skip_ws_and_comments
+          value_start = @_pos
+
+          # Scan to the terminating ';', honoring quoted strings and paren
+          # depth so a URI given as url(...) can't have a stray ';' inside
+          # it (e.g. a data: URI) end the statement early.
+          in_quote = nil
+          paren_depth = 0
+
+          until eof?
+            byte = peek_byte
+
+            if in_quote
+              if byte == in_quote
+                in_quote = nil
+              elsif byte == BYTE_BACKSLASH && @_pos + 1 < @_len
+                @_pos += 1
+              end
+            else
+              break if byte == BYTE_SEMICOLON && paren_depth == 0
+
+              if byte == BYTE_SQUOTE || byte == BYTE_DQUOTE # rubocop:disable Style/CaseLikeIf
+                in_quote = byte
+              elsif byte == BYTE_LPAREN
+                paren_depth += 1
+              elsif byte == BYTE_RPAREN
+                paren_depth -= 1
+              end
+            end
+
+            @_pos += 1
+          end
+
+          return if eof? # malformed: no terminating ';'
+
+          content_end = @_pos
+          content_end -= 1 while content_end > value_start && whitespace?(@_css.getbyte(content_end - 1))
+          @_pos += 1 # skip ';'
+
+          return if content_end <= value_start # "@namespace;" - nothing to declare
+
+          selector = byteslice_encoded(at_rule_start, content_end - at_rule_start)
+
+          rule_id = @_rule_id_counter
+          @_rule_id_counter += 1
+          @rules << AtRule.new(rule_id, selector, nil, nil, @_parent_media_query_id, @_parent_conditional_group_id)
+        end
+
+        # Split a raw @container prelude into [name, condition]:
+        #   "sidebar (min-width: 400px)" -> ["sidebar", "(min-width: 400px)"]
+        #   "(min-width: 400px)"         -> [nil, "(min-width: 400px)"]
+        #   "sidebar"                   -> ["sidebar", nil]
+        #   "not (min-width: 400px)"    -> [nil, "not (min-width: 400px)"] (anonymous - "not" isn't a valid container-query name ident)
+        #   "sidebar not (min-width: 400px)" -> ["sidebar", "not (min-width: 400px)"]
+        def split_container_prelude(raw)
+          return [nil, raw] if raw.start_with?('(')
+
+          # (start, length) form avoids allocating a Range, unlike raw[(i+1)..]
+          space_idx = raw.index(' ')
+          first_word = space_idx ? raw[0, space_idx] : raw
+
+          return [nil, raw] if first_word.casecmp?('not') # allocation-free vs first_word.downcase == 'not'
+          return [first_word, nil] unless space_idx
+
+          # Caller already stripped raw's own leading/trailing whitespace, so
+          # only a leading gap between name and condition can remain here -
+          # lstrip! (in place, on this fresh slice) instead of strip (which
+          # would allocate a second string to also re-check the trailing end)
+          rest = raw[space_idx + 1, raw.length]
+          rest.lstrip!
+          [first_word, rest.empty? ? nil : rest]
+        end
+
         # @supports, @layer, @container, @scope - behave like @media but don't
-        # affect media context, so unlike parse_media_at_rule there's no media
-        # query/media_query_id merging to do on top of the shared nested-parser
-        # result merge.
+        # affect media context (so no combining, unlike parse_media_at_rule -
+        # a nested @media's MediaQuery objects just need to be re-housed in
+        # this parser's own @media_queries with offset ids, same as any other
+        # nested-parser result).
+        #
+        # @supports, @container, and @layer's block form build a real
+        # ConditionalGroup and tag their child rules with a
+        # conditional_group_id - @scope still just recurses and passes the
+        # parent context through unchanged (its condition/name text is only
+        # used for the missing-condition validation below, same as before).
+        # It gets its own faithful representation in its own follow-up bead.
+        #
+        # @layer also has a statement form (`@layer name, name;`, no block at
+        # all) - handled separately below, since there are no rules to wrap.
         #
         # @param at_rule_name [String] The at-rule name (e.g. "supports"), used
         #   to decide whether a condition is required and for error messages
-        def parse_conditional_group_at_rule(at_rule_name)
+        # @param at_rule_start [Integer] Position of the at-rule's leading '@',
+        #   used to build a verbatim selector for the statement form
+        def parse_conditional_group_at_rule(at_rule_name, at_rule_start)
           skip_ws_and_comments
 
           # Remember start of condition for error reporting
           condition_start = @_pos
 
-          # Skip to opening brace
-          condition_end = @_pos
-          while !eof? && peek_byte != BYTE_LBRACE
-            condition_end = @_pos
+          # Skip to whichever terminator comes first: '{' (block form) or ';'
+          # (statement form - only valid for @layer, but we still stop there
+          # for the others rather than scanning straight through it into
+          # whatever rule happens to follow)
+          while !eof? && peek_byte != BYTE_LBRACE && peek_byte != BYTE_SEMICOLON
             @_pos += 1
           end
 
-          return if eof? || peek_byte != BYTE_LBRACE
+          return if eof?
+
+          if peek_byte == BYTE_SEMICOLON
+            parse_layer_statement(at_rule_start, condition_start) if at_rule_name == 'layer'
+            @_pos += 1 # skip ';'
+            return
+          end
+
+          condition_str = byteslice_encoded(condition_start, @_pos - condition_start).strip
 
           # Validate condition (strict mode) - @supports, @container, @scope require conditions
-          if @_check_malformed_at_rules && (at_rule_name == 'supports' || at_rule_name == 'container' || at_rule_name == 'scope')
-            condition_str = byteslice_encoded(condition_start, condition_end - condition_start).strip
-            if condition_str.empty?
-              raise ParseError.new("Malformed @#{at_rule_name}: missing condition",
-                                   css: @_css, pos: condition_start, type: :malformed_at_rule)
-            end
+          if @_check_malformed_at_rules && (at_rule_name == 'supports' || at_rule_name == 'container' || at_rule_name == 'scope') && condition_str.empty?
+            raise ParseError.new("Malformed @#{at_rule_name}: missing condition",
+                                 css: @_css, pos: condition_start, type: :malformed_at_rule)
           end
 
           @_pos += 1 # skip '{'
@@ -1156,11 +1305,32 @@ module Cataract
             raise DepthError, "CSS nesting too deep: exceeded maximum depth of #{MAX_PARSE_DEPTH}"
           end
 
+          # For @supports/@container/@layer, build a ConditionalGroup (nested
+          # inside the enclosing one, if any) and tag every rule parsed
+          # inside this block with it.
+          child_conditional_group_id = @_parent_conditional_group_id
+          if at_rule_name == 'layer' || !condition_str.empty?
+            name, condition = case at_rule_name
+                              when 'supports' then [nil, condition_str]
+                              when 'container' then split_container_prelude(condition_str)
+                              when 'layer' then [condition_str.empty? ? nil : condition_str, nil]
+                              end
+
+            if condition || name || at_rule_name == 'layer'
+              group = Cataract::ConditionalGroup.new(@_conditional_group_id_counter, at_rule_name.to_sym, name,
+                                                     condition, @_parent_conditional_group_id)
+              @conditional_groups << group
+              child_conditional_group_id = @_conditional_group_id_counter
+              @_conditional_group_id_counter += 1
+            end
+          end
+
           # Recursively parse block content (preserve parent media context)
           nested_parser = Parser.new(
             byteslice_encoded(block_start, block_end - block_start),
             parser_options: @_parser_options,
             parent_media_sym: @_parent_media_sym,
+            parent_conditional_group_id: child_conditional_group_id,
             depth: @_depth + 1
           )
 
@@ -1169,13 +1339,69 @@ module Cataract
           # NOTE: We no longer build media_index during parse
           # It will be built from MediaQuery objects after import resolution
           list_id_offset = merge_nested_selector_lists(nested_result)
-          merge_nested_rules(nested_result, list_id_offset)
+
+          # Merge nested MediaQuery objects/lists with offsetted ids - a
+          # @media discovered inside this block needs to land in OUR
+          # @media_queries, not just the nested parser's own local one
+          # (parse_media_at_rule does the equivalent for its own nesting).
+          mq_id_offset = @_media_query_id_counter
+          if nested_result[:media_queries] && !nested_result[:media_queries].empty?
+            nested_result[:media_queries].each do |mq|
+              @media_queries << Cataract::MediaQuery.new(mq.id + mq_id_offset, mq.type, mq.conditions)
+            end
+            @_media_query_id_counter += nested_result[:media_queries].size
+          end
+
+          if nested_result[:_media_query_lists] && !nested_result[:_media_query_lists].empty?
+            nested_result[:_media_query_lists].each do |list_id, mq_ids|
+              new_list_id = list_id + @_next_media_query_list_id
+              @_media_query_lists[new_list_id] = mq_ids.map { |mq_id| mq_id + mq_id_offset }
+            end
+            @_next_media_query_list_id += nested_result[:_media_query_lists].size
+          end
+
+          # Merge nested ConditionalGroup objects (for @supports nested
+          # inside @supports).
+          old_to_new_cg_id = merge_nested_conditional_groups(nested_result)
+
+          merge_nested_rules(nested_result, list_id_offset) do |rule|
+            rule.media_query_id += mq_id_offset if rule.media_query_id
+            if rule.conditional_group_id.nil?
+              rule.conditional_group_id = child_conditional_group_id if rule.respond_to?(:conditional_group_id=)
+            elsif old_to_new_cg_id.key?(rule.conditional_group_id)
+              rule.conditional_group_id = old_to_new_cg_id[rule.conditional_group_id]
+            end
+            # else: already an external reference (e.g. == child_conditional_group_id,
+            # inherited via pass-through from an intermediate @media), leave unchanged
+          end
 
           # Move position past the closing brace
           @_pos = block_end
           @_pos += 1 if @_pos < @_len && @_css.getbyte(@_pos) == BYTE_RBRACE
         end
 
+        # @layer name, name; - the statement form declares layer order
+        # without wrapping any rules, so unlike the block form there's
+        # nothing to tag with a conditional_group_id. Represented as an
+        # AtRule instead (mirrors @keyframes/@font-face's "content varies by
+        # type" pattern), with content nil since there's no block to hold.
+        # Called with @_pos at the ';' that terminates the statement.
+        #
+        # @param at_rule_start [Integer] Position of the at-rule's leading '@'
+        # @param condition_start [Integer] Position where the name list
+        #   begins (right after "@layer" and any whitespace)
+        def parse_layer_statement(at_rule_start, condition_start)
+          content_end = @_pos
+          content_end -= 1 while content_end > condition_start && whitespace?(@_css.getbyte(content_end - 1))
+          return if content_end <= condition_start # "@layer;" / "@layer   ;" - no names, nothing to declare
+
+          selector = byteslice_encoded(at_rule_start, content_end - at_rule_start)
+
+          rule_id = @_rule_id_counter
+          @_rule_id_counter += 1
+          @rules << AtRule.new(rule_id, selector, nil, nil, @_parent_media_query_id, @_parent_conditional_group_id)
+        end
+
         # @media - parses the media query, recurses into a nested Parser for the
         # block content (combining its media context with any parent), and
         # merges the result. Unlike parse_conditional_group_at_rule, this also
@@ -1259,11 +1485,15 @@ module Cataract
 
           # Parse the content with the combined media context
           # Note: We don't pass parent_media_query_id because MediaQuery IDs are local to each parser
-          # The nested parser will create its own MediaQueries, which we'll merge with offsetted IDs
+          # The nested parser will create its own MediaQueries, which we'll merge with offsetted IDs.
+          # parent_conditional_group_id IS passed through unchanged (@media doesn't create or affect
+          # conditional-group context) so a @supports nested inside this @media computes the right
+          # parent_id chain if this @media is itself nested inside an outer @supports.
           nested_parser = Parser.new(
             byteslice_encoded(block_start, block_end - block_start),
             parser_options: @_parser_options,
             parent_media_sym: combined_media_sym,
+            parent_conditional_group_id: @_parent_conditional_group_id,
             depth: @_depth + 1
           )
 
@@ -1297,6 +1527,10 @@ module Cataract
           # Note: We no longer build media_index during parse
           # It will be built from MediaQuery objects after import resolution
 
+          # Merge nested ConditionalGroup objects (for a @supports discovered
+          # inside this @media block).
+          old_to_new_cg_id = merge_nested_conditional_groups(nested_result)
+
           merge_nested_rules(nested_result, list_id_offset) do |rule|
             # Update media_query_id if applicable (both Rule and AtRule can have media_query_id)
             if rule.media_query_id
@@ -1325,6 +1559,14 @@ module Cataract
               # (applies to both Rule and AtRule)
               rule.media_query_id = combined_media_query_id
             end
+
+            # @media doesn't create or affect conditional-group context. Only
+            # remap an id that matches a group we just merged above (a
+            # @supports nested inside this @media) - anything else (nil, or
+            # an external reference) is left alone, for whichever conditional
+            # group actually encloses this @media (if any) to assign at its
+            # own merge step. Assigning it here too would double-process it.
+            rule.conditional_group_id = old_to_new_cg_id[rule.conditional_group_id] if old_to_new_cg_id.key?(rule.conditional_group_id)
           end
 
           # Move position past the closing brace
@@ -1369,7 +1611,7 @@ module Cataract
           @_rule_id_counter += 1
 
           # Create AtRule with nested rules
-          at_rule = AtRule.new(rule_id, selector, content, nil, @_parent_media_query_id)
+          at_rule = AtRule.new(rule_id, selector, content, nil, @_parent_media_query_id, @_parent_conditional_group_id)
           @rules << at_rule
         end
 
@@ -1398,7 +1640,7 @@ module Cataract
           @_rule_id_counter += 1
 
           # Create AtRule with declarations
-          at_rule = AtRule.new(rule_id, selector, content, nil, @_parent_media_query_id)
+          at_rule = AtRule.new(rule_id, selector, content, nil, @_parent_media_query_id, @_parent_conditional_group_id)
           @rules << at_rule
         end