cataract 0.2.2 → 0.2.4

data/ext/cataract/flatten.c

@@ -620,24 +620,87 @@ struct flatten_selectors_context {
     int *rule_id_counter;
     long selector_index;
     long total_selectors;
+    VALUE old_to_new_id;  // Hash mapping old rule IDs to new merged rule IDs (for media index)
 };
 
+// Context for remapping media_index
+struct remap_media_context {
+    VALUE old_to_new_id;
+    VALUE new_media_index;
+};
+
+// Callback for remapping media_index entries
+static int remap_media_index_callback(VALUE media_sym, VALUE old_rule_ids, VALUE arg) {
+    struct remap_media_context *ctx = (struct remap_media_context *)arg;
+
+    if (NIL_P(old_rule_ids) || TYPE(old_rule_ids) != T_ARRAY) {
+        return ST_CONTINUE;
+    }
+
+    VALUE new_rule_ids = rb_ary_new();
+    long num_old_ids = RARRAY_LEN(old_rule_ids);
+
+    for (long i = 0; i < num_old_ids; i++) {
+        VALUE old_id = RARRAY_AREF(old_rule_ids, i);
+        VALUE new_id = rb_hash_aref(ctx->old_to_new_id, old_id);
+
+        // Only include if the rule still exists after merging and isn't already in the list
+        if (!NIL_P(new_id) && rb_ary_includes(new_rule_ids, new_id) == Qfalse) {
+            rb_ary_push(new_rule_ids, new_id);
+        }
+    }
+
+    // Only preserve media entry if there are still rules for it
+    if (RARRAY_LEN(new_rule_ids) > 0) {
+        rb_hash_aset(ctx->new_media_index, media_sym, new_rule_ids);
+    }
+
+    return ST_CONTINUE;
+}
+
 // Forward declaration
 static VALUE flatten_rules_for_selector(VALUE rules_array, VALUE rule_indices, VALUE selector, VALUE *out_selector_list_id);
 
 // Callback for rb_hash_foreach when merging selector groups
-static int flatten_selector_group_callback(VALUE selector, VALUE group_indices, VALUE arg) {
+static int flatten_selector_group_callback(VALUE group_key, VALUE group_indices, VALUE arg) {
     struct flatten_selectors_context *ctx = (struct flatten_selectors_context *)arg;
     ctx->selector_index++;
 
-    DEBUG_PRINTF("\n[Selector %ld/%ld] '%s' - %ld rules in group\n",
+    // Extract selector and media_context from group_key array [selector, media_context]
+    VALUE selector = RARRAY_AREF(group_key, 0);
+    VALUE media_context = RARRAY_AREF(group_key, 1);
+
+    DEBUG_PRINTF("\n[Selector %ld/%ld] '%s' (media=%s) - %ld rules in group\n",
                  ctx->selector_index, ctx->total_selectors,
-                 RSTRING_PTR(selector), RARRAY_LEN(group_indices));
+                 RSTRING_PTR(selector),
+                 NIL_P(media_context) ? "nil" : RSTRING_PTR(rb_inspect(media_context)),
+                 RARRAY_LEN(group_indices));
 
     // Merge all rules in this selector group and preserve selector_list_id if all rules share same ID
     VALUE selector_list_id = Qnil;
     VALUE merged_decls = flatten_rules_for_selector(ctx->rules_array, group_indices, selector, &selector_list_id);
 
+    int new_rule_id = *ctx->rule_id_counter;
+
+    // Extract media_query_id from first rule in group (all should have same media_query_id)
+    VALUE media_query_id = Qnil;
+    if (RARRAY_LEN(group_indices) > 0) {
+        long first_rule_idx = FIX2LONG(RARRAY_AREF(group_indices, 0));
+        VALUE first_rule = RARRAY_AREF(ctx->rules_array, first_rule_idx);
+        media_query_id = rb_struct_aref(first_rule, INT2FIX(RULE_MEDIA_QUERY_ID));
+    }
+
+    // Track old rule IDs to new rule ID mapping (only for rules in media queries)
+    if (!NIL_P(media_context)) {
+        long num_rules_in_group = RARRAY_LEN(group_indices);
+        for (long i = 0; i < num_rules_in_group; i++) {
+            long old_rule_idx = FIX2LONG(RARRAY_AREF(group_indices, i));
+            VALUE old_rule = RARRAY_AREF(ctx->rules_array, old_rule_idx);
+            VALUE old_rule_id = rb_struct_aref(old_rule, INT2FIX(RULE_ID));
+            rb_hash_aset(ctx->old_to_new_id, old_rule_id, INT2FIX(new_rule_id));
+        }
+    }
+
     // Create new rule with this selector and merged declarations
     VALUE new_rule = rb_struct_new(cRule,
         INT2FIX((*ctx->rule_id_counter)++),
@@ -646,7 +709,8 @@ static int flatten_selector_group_callback(VALUE selector, VALUE group_indices,
         Qnil,  // specificity
         Qnil,  // parent_rule_id
         Qnil,  // nesting_style
-        selector_list_id  // Preserve selector_list_id if all rules in group share same ID
+        selector_list_id,  // Preserve selector_list_id if all rules in group share same ID
+        media_query_id  // Preserve media_query_id from source rules
     );
     rb_ary_push(ctx->merged_rules, new_rule);
 
@@ -1114,6 +1178,81 @@ static int declarations_equal(VALUE decls1, VALUE decls2) {
     return 1;
 }
 
+// Context for iterating through rules_by_list hash
+struct check_selector_lists_ctx {
+    VALUE selector_lists;  // Output hash to populate
+};
+
+// Callback for iterating through rules_by_list hash: list_id => [rule1, rule2, ...]
+static int check_selector_list_callback(VALUE list_id, VALUE rules_in_list, VALUE arg) {
+    struct check_selector_lists_ctx *ctx = (struct check_selector_lists_ctx *)arg;
+    long num_in_list = RARRAY_LEN(rules_in_list);
+
+    DEBUG_PRINTF("\n  Checking list_id=%ld: %ld rules\n", NUM2LONG(list_id), num_in_list);
+
+    // Skip if only one rule in list (nothing to compare)
+    if (num_in_list <= 1) {
+        DEBUG_PRINTF("    -> Only 1 rule, skipping\n");
+        return ST_CONTINUE;
+    }
+
+    // Get first rule as reference
+    VALUE reference_rule = RARRAY_AREF(rules_in_list, 0);
+    VALUE reference_decls = rb_struct_aref(reference_rule, INT2FIX(RULE_DECLARATIONS));
+#ifdef CATARACT_DEBUG
+    VALUE reference_selector = rb_struct_aref(reference_rule, INT2FIX(RULE_SELECTOR));
+    DEBUG_PRINTF("    Reference rule: selector=%s, %ld declarations\n",
+                 RSTRING_PTR(reference_selector), RARRAY_LEN(reference_decls));
+#endif
+
+    // Find rules that still match (have identical declarations)
+    VALUE matching_rules = rb_ary_new();
+    rb_ary_push(matching_rules, reference_rule);
+
+    for (long j = 1; j < num_in_list; j++) {
+        VALUE rule = RARRAY_AREF(rules_in_list, j);
+        VALUE decls = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
+#ifdef CATARACT_DEBUG
+        VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+        DEBUG_PRINTF("    Comparing rule %ld (selector=%s):\n", j, RSTRING_PTR(selector));
+#endif
+
+        if (declarations_equal(reference_decls, decls)) {
+            DEBUG_PRINTF("      -> MATCHES reference, keeping in list\n");
+            rb_ary_push(matching_rules, rule);
+        } else {
+            DEBUG_PRINTF("      -> DIVERGED from reference, clearing selector_list_id\n");
+            // Clear selector_list_id for diverged rule
+            rb_struct_aset(rule, INT2FIX(RULE_SELECTOR_LIST_ID), Qnil);
+        }
+    }
+
+    // Only keep the selector list if at least 2 rules still match
+    long num_matching = RARRAY_LEN(matching_rules);
+    DEBUG_PRINTF("    Result: %ld/%ld rules still match\n", num_matching, num_in_list);
+
+    if (num_matching >= 2) {
+        // Build selector_lists hash with NEW rule IDs
+        VALUE rule_ids = rb_ary_new_capa(num_matching);
+        for (long j = 0; j < num_matching; j++) {
+            VALUE rule = RARRAY_AREF(matching_rules, j);
+            VALUE rule_id = rb_struct_aref(rule, INT2FIX(RULE_ID));
+            rb_ary_push(rule_ids, rule_id);
+        }
+        rb_hash_aset(ctx->selector_lists, list_id, rule_ids);
+        DEBUG_PRINTF("    -> Keeping selector list with %ld rules\n", num_matching);
+    } else {
+        DEBUG_PRINTF("    -> Only 1 rule left, clearing selector_list_id for it too\n");
+        // Clear selector_list_id for the last remaining rule too
+        for (long j = 0; j < num_matching; j++) {
+            VALUE rule = RARRAY_AREF(matching_rules, j);
+            rb_struct_aset(rule, INT2FIX(RULE_SELECTOR_LIST_ID), Qnil);
+        }
+    }
+
+    return ST_CONTINUE;
+}
+
 /*
  * Update selector lists to remove diverged rules
  *
@@ -1165,77 +1304,9 @@ static void update_selector_lists_for_divergence(VALUE merged_rules, VALUE selec
     }
 
     // For each selector list, check if declarations still match
-    VALUE list_ids = rb_funcall(rules_by_list, rb_intern("keys"), 0);
-    long num_lists = RARRAY_LEN(list_ids);
-    DEBUG_PRINTF("  Found %ld selector list groups to check\n", num_lists);
-
-    for (long i = 0; i < num_lists; i++) {
-        VALUE list_id = RARRAY_AREF(list_ids, i);
-        VALUE rules_in_list = rb_hash_aref(rules_by_list, list_id);
-        long num_in_list = RARRAY_LEN(rules_in_list);
-
-        DEBUG_PRINTF("\n  Checking list_id=%ld: %ld rules\n", NUM2LONG(list_id), num_in_list);
-
-        // Skip if only one rule in list (nothing to compare)
-        if (num_in_list <= 1) {
-            DEBUG_PRINTF("    -> Only 1 rule, skipping\n");
-            continue;
-        }
-
-        // Get first rule as reference
-        VALUE reference_rule = RARRAY_AREF(rules_in_list, 0);
-        VALUE reference_decls = rb_struct_aref(reference_rule, INT2FIX(RULE_DECLARATIONS));
-#ifdef CATARACT_DEBUG
-        VALUE reference_selector = rb_struct_aref(reference_rule, INT2FIX(RULE_SELECTOR));
-        DEBUG_PRINTF("    Reference rule: selector=%s, %ld declarations\n",
-                     RSTRING_PTR(reference_selector), RARRAY_LEN(reference_decls));
-#endif
-
-        // Find rules that still match (have identical declarations)
-        VALUE matching_rules = rb_ary_new();
-        rb_ary_push(matching_rules, reference_rule);
-
-        for (long j = 1; j < num_in_list; j++) {
-            VALUE rule = RARRAY_AREF(rules_in_list, j);
-            VALUE decls = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
-#ifdef CATARACT_DEBUG
-            VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
-            DEBUG_PRINTF("    Comparing rule %ld (selector=%s):\n", j, RSTRING_PTR(selector));
-#endif
-
-            if (declarations_equal(reference_decls, decls)) {
-                DEBUG_PRINTF("      -> MATCHES reference, keeping in list\n");
-                rb_ary_push(matching_rules, rule);
-            } else {
-                DEBUG_PRINTF("      -> DIVERGED from reference, clearing selector_list_id\n");
-                // Clear selector_list_id for diverged rule
-                rb_struct_aset(rule, INT2FIX(RULE_SELECTOR_LIST_ID), Qnil);
-            }
-        }
-
-        // Only keep the selector list if at least 2 rules still match
-        long num_matching = RARRAY_LEN(matching_rules);
-        DEBUG_PRINTF("    Result: %ld/%ld rules still match\n", num_matching, num_in_list);
-
-        if (num_matching >= 2) {
-            // Build selector_lists hash with NEW rule IDs
-            VALUE rule_ids = rb_ary_new_capa(num_matching);
-            for (long j = 0; j < num_matching; j++) {
-                VALUE rule = RARRAY_AREF(matching_rules, j);
-                VALUE rule_id = rb_struct_aref(rule, INT2FIX(RULE_ID));
-                rb_ary_push(rule_ids, rule_id);
-            }
-            rb_hash_aset(selector_lists, list_id, rule_ids);
-            DEBUG_PRINTF("    -> Keeping selector list with %ld rules\n", num_matching);
-        } else {
-            DEBUG_PRINTF("    -> Only 1 rule left, clearing selector_list_id for it too\n");
-            // Clear selector_list_id for the last remaining rule too
-            for (long j = 0; j < num_matching; j++) {
-                VALUE rule = RARRAY_AREF(matching_rules, j);
-                rb_struct_aset(rule, INT2FIX(RULE_SELECTOR_LIST_ID), Qnil);
-            }
-        }
-    }
+    DEBUG_PRINTF("  Found %ld selector list groups to check\n", RHASH_SIZE(rules_by_list));
+    struct check_selector_lists_ctx ctx = { selector_lists };
+    rb_hash_foreach(rules_by_list, check_selector_list_callback, (VALUE)&ctx);
 
     DEBUG_PRINTF("\n=== End divergence tracking: %ld selector lists preserved ===\n\n", RHASH_SIZE(selector_lists));
 }
@@ -1372,10 +1443,32 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
         }
     }
 
-    // ALWAYS build selector groups - this is the core of flatten logic
-    // Group rules by selector: different selectors stay separate
-    // selector => [rule indices]
-    DEBUG_PRINTF("\n=== Building selector groups (has_nesting=%d) ===\n", has_nesting);
+    // Build rule_media_map: rule_id => media_query_id
+    // This is used to group rules by (selector, media) instead of just selector
+    VALUE input_media_index = Qnil;
+    VALUE rule_media_map = rb_hash_new();
+    if (rb_obj_is_kind_of(input, cStylesheet)) {
+        input_media_index = rb_ivar_get(input, id_ivar_media_index);
+
+        // Build map from rules' media_query_id field
+        // Only process Rule objects, not AtRules (AtRules don't have media_query_id field at same offset)
+        for (long i = 0; i < num_rules; i++) {
+            VALUE rule = rb_ary_entry(rules_array, i);
+            if (!rb_obj_is_kind_of(rule, cAtRule)) {
+                VALUE media_query_id = rb_struct_aref(rule, INT2FIX(RULE_MEDIA_QUERY_ID));
+                if (!NIL_P(media_query_id)) {
+                    VALUE rule_id = rb_struct_aref(rule, INT2FIX(RULE_ID));
+                    // Store media_query_id as the grouping key
+                    rb_hash_aset(rule_media_map, rule_id, media_query_id);
+                }
+            }
+        }
+    }
+
+    // Group rules by (selector, media) instead of just selector
+    // Rules with same selector but different media contexts should NOT be merged
+    // selector_and_media_key => [rule indices]
+    DEBUG_PRINTF("\n=== Building selector+media groups (has_nesting=%d) ===\n", has_nesting);
     VALUE selector_groups = rb_hash_new();
     VALUE passthrough_rules = rb_ary_new(); // AtRules to pass through unchanged
 
@@ -1392,6 +1485,7 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
 
         VALUE declarations = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
         VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+        VALUE rule_id_val = rb_struct_aref(rule, INT2FIX(RULE_ID));
 
         // Skip empty rules (no declarations)
         // This handles both empty containers and rules with no properties
@@ -1407,18 +1501,28 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
         // Should output both .parent (color: red) and .parent .child (color: blue)
         // The nesting is already flattened during parsing, so they have different selectors.
 
-        DEBUG_PRINTF("  [Rule %ld] ADD: selector='%s', %ld declarations\n",
-                     i, RSTRING_PTR(selector), RARRAY_LEN(declarations));
+        // Get media context for this rule (nil if not in media query)
+        VALUE media_context = rb_hash_aref(rule_media_map, rule_id_val);
+
+        // Build grouping key as [selector, media_context]
+        VALUE group_key = rb_ary_new3(2, selector, media_context);
+
+        DEBUG_PRINTF("  [Rule %ld] ADD: selector='%s', media=%s, %ld declarations\n",
+                     i, RSTRING_PTR(selector),
+                     NIL_P(media_context) ? "nil" : RSTRING_PTR(rb_inspect(media_context)),
+                     RARRAY_LEN(declarations));
 
-        VALUE group = rb_hash_aref(selector_groups, selector);
+        VALUE group = rb_hash_aref(selector_groups, group_key);
         if (NIL_P(group)) {
             group = rb_ary_new();
-            rb_hash_aset(selector_groups, selector, group);
-            DEBUG_PRINTF("    -> Created new selector group for '%s'\n", RSTRING_PTR(selector));
+            rb_hash_aset(selector_groups, group_key, group);
+            DEBUG_PRINTF("    -> Created new selector+media group for '%s' + %s\n",
+                        RSTRING_PTR(selector),
+                        NIL_P(media_context) ? "nil" : RSTRING_PTR(rb_inspect(media_context)));
         }
         rb_ary_push(group, LONG2FIX(i));
     }
-    DEBUG_PRINTF("=== Total selector groups: %ld ===\n\n", RHASH_SIZE(selector_groups));
+    DEBUG_PRINTF("=== Total selector+media groups: %ld ===\n\n", RHASH_SIZE(selector_groups));
 
     // ALWAYS group by selector and keep them separate
     // Different selectors target different elements and must remain distinct
@@ -1444,6 +1548,16 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
         VALUE media_idx = rb_hash_new();
         rb_ivar_set(passthrough_sheet, id_ivar_media_index, media_idx);
 
+        // Copy @media_queries and @_media_query_lists from input
+        if (rb_obj_is_kind_of(input, cStylesheet)) {
+            VALUE media_queries = rb_ivar_get(input, rb_intern("@media_queries"));
+            VALUE media_query_lists = rb_ivar_get(input, rb_intern("@_media_query_lists"));
+            Check_Type(media_queries, T_ARRAY);
+            if (!NIL_P(media_query_lists)) Check_Type(media_query_lists, T_HASH);
+            rb_ivar_set(passthrough_sheet, rb_intern("@media_queries"), media_queries);
+            rb_ivar_set(passthrough_sheet, rb_intern("@_media_query_lists"), media_query_lists);
+        }
+
         return passthrough_sheet;
     }
 
@@ -1456,12 +1570,14 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
 
         // Iterate through each selector group using rb_hash_foreach
         // to avoid rb_funcall in hot path
+        VALUE old_to_new_id = rb_hash_new();  // Hash to track old rule IDs -> new merged rule IDs
         struct flatten_selectors_context merge_ctx;
         merge_ctx.merged_rules = merged_rules;
         merge_ctx.rules_array = rules_array;
         merge_ctx.rule_id_counter = &rule_id_counter;
         merge_ctx.selector_index = 0;
         merge_ctx.total_selectors = RHASH_SIZE(selector_groups);
+        merge_ctx.old_to_new_id = old_to_new_id;
 
         DEBUG_PRINTF("\n=== Processing %ld selector groups ===\n", merge_ctx.total_selectors);
 
@@ -1512,15 +1628,40 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
             }
         }
 
-        // Set @media_index to empty hash (no media rules after flatten)
-        // NOTE: Setting to empty hash instead of { all: [ids] } to match pure Ruby behavior
-        // and avoid wrapping output in @media all during serialization
-        VALUE media_idx = rb_hash_new();
-        rb_ivar_set(merged_sheet, id_ivar_media_index, media_idx);
+        // Preserve media_index by remapping old rule IDs to new rule IDs
+        // This is important for @media rules and @import statements with media constraints
+        VALUE new_media_index = rb_hash_new();
+
+        if (!NIL_P(input_media_index) && TYPE(input_media_index) == T_HASH) {
+            struct remap_media_context remap_ctx;
+            remap_ctx.old_to_new_id = old_to_new_id;
+            remap_ctx.new_media_index = new_media_index;
+            rb_hash_foreach(input_media_index, remap_media_index_callback, (VALUE)&remap_ctx);
+        }
+
+        rb_ivar_set(merged_sheet, id_ivar_media_index, new_media_index);
+
+        // Copy @media_queries and @_media_query_lists from input (these don't change during flatten)
+        if (rb_obj_is_kind_of(input, cStylesheet)) {
+            VALUE media_queries = rb_ivar_get(input, rb_intern("@media_queries"));
+            VALUE media_query_lists = rb_ivar_get(input, rb_intern("@_media_query_lists"));
+            Check_Type(media_queries, T_ARRAY);
+            if (!NIL_P(media_query_lists)) Check_Type(media_query_lists, T_HASH);
+            rb_ivar_set(merged_sheet, rb_intern("@media_queries"), media_queries);
+            rb_ivar_set(merged_sheet, rb_intern("@_media_query_lists"), media_query_lists);
+        }
 
         // Set @_selector_lists with divergence tracking
         rb_ivar_set(merged_sheet, rb_intern("@_selector_lists"), selector_lists);
 
+        // Protect intermediate VALUEs from being collected
+        RB_GC_GUARD(input_media_index);
+        RB_GC_GUARD(rule_media_map);
+        RB_GC_GUARD(selector_groups);
+        RB_GC_GUARD(passthrough_rules);
+        RB_GC_GUARD(old_to_new_id);
+        RB_GC_GUARD(new_media_index);
+
         return merged_sheet;
     }
 
@@ -1986,7 +2127,8 @@ VALUE cataract_flatten(VALUE self, VALUE input) {
         Qnil,                     // specificity (not applicable)
         Qnil,                     // parent_rule_id (not nested)
         Qnil,                     // nesting_style (not nested)
-        Qnil                      // selector_list_id
+        Qnil,                     // selector_list_id
+        Qnil                      // media_query_id
     );
 
     // Set @rules array with single merged rule (use cached ID)

data/ext/cataract/shorthand_expander.c

@@ -882,6 +882,13 @@ VALUE cataract_create_background_shorthand(VALUE self, VALUE properties) {
         rb_str_append(result, size);
     }
 
+    // If all properties are defaults, the result would be empty
+    // In this case, use "none" which is equivalent to all-default background
+    if (RSTRING_LEN(result) == 0) {
+        DEBUG_PRINTF("[create_background_shorthand] All defaults omitted, using 'none'\n");
+        return USASCII_STR("none");
+    }
+
     DEBUG_PRINTF("[create_background_shorthand] result='%s'\n", RSTRING_PTR(result));
     return result;
 }

data/lib/cataract/at_rule.rb

@@ -28,7 +28,8 @@ module Cataract
   # @attr [String] selector The at-rule identifier (e.g., "@keyframes fade", "@font-face")
   # @attr [Array<Rule>, Array<Declaration>] content Nested rules or declarations
   # @attr [nil] specificity Always nil for at-rules (they don't have CSS specificity)
-  AtRule = Struct.new(:id, :selector, :content, :specificity) unless const_defined?(:AtRule)
+  # @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)
 
   class AtRule
     # Check if this is a selector-based rule (vs an at-rule like @keyframes).

data/lib/cataract/constants.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cataract
+  # Default URI resolver proc for converting relative URLs to absolute
+  # Uses Ruby's URI stdlib to merge base and relative URIs
+  DEFAULT_URI_RESOLVER = lambda { |base, relative|
+    require 'uri'
+    URI.parse(base).merge(relative).to_s
+  }.freeze
+end

data/lib/cataract/import_resolver.rb

@@ -20,7 +20,7 @@ module Cataract
       # @return [String] Fetched content
       # @raise [ImportError] If fetching fails
       def call(url, options)
-        uri = ImportResolver.normalize_url(url, options[:base_path])
+        uri = ImportResolver.normalize_url(url, base_path: options[:base_path], base_uri: options[:base_uri])
 
         case uri.scheme
         when 'file'
@@ -56,6 +56,7 @@ module Cataract
         uri.open(open_uri_options, &:read)
       end
     end
+
     # Default options for safe import resolution
     SAFE_DEFAULTS = {
       max_depth: 5,                      # Prevent infinite recursion
@@ -63,81 +64,11 @@ module Cataract
       extensions: ['css'],               # Only .css files
       timeout: 10,                       # 10 second timeout for fetches
       follow_redirects: true,            # Follow redirects
-      base_path: nil,                    # Base path for resolving relative imports
+      base_path: nil,                    # Base path for resolving relative file imports
+      base_uri: nil,                     # Base URI for resolving relative HTTP imports
       fetcher: nil                       # Custom fetcher (defaults to DefaultFetcher)
     }.freeze
 
-    # Resolve @import statements in CSS
-    #
-    # @param css [String] CSS content with @import statements
-    # @param options [Hash] Import resolution options
-    #   @option options [#call] :fetcher Custom fetcher callable (receives url, options)
-    #   @option options [Integer] :max_depth Maximum import nesting depth
-    #   @option options [Array<String>] :allowed_schemes Allowed URL schemes
-    #   @option options [Array<String>] :extensions Allowed file extensions
-    #   @option options [Integer] :timeout HTTP request timeout in seconds
-    #   @option options [Boolean] :follow_redirects Follow HTTP redirects
-    #   @option options [String] :base_path Base path for relative imports
-    # @param depth [Integer] Current recursion depth (internal)
-    # @param imported_urls [Array] Array of already imported URLs to prevent circular references
-    # @return [String] CSS with imports inlined
-    def self.resolve(css, options = {}, depth: 0, imported_urls: [])
-      # Normalize options
-      opts = normalize_options(options)
-
-      # Get or create fetcher
-      fetcher = opts[:fetcher] || DefaultFetcher.new
-
-      # Check recursion depth
-      # depth starts at 0, max_depth is count of imports allowed
-      # depth 0: parsing main file (counts as import 1)
-      # depth 1: parsing first @import  (counts as import 2)
-      # depth 2: parsing nested @import (counts as import 3)
-      if depth > opts[:max_depth]
-        raise ImportError, "Import nesting too deep: exceeded maximum depth of #{opts[:max_depth]}"
-      end
-
-      # Find all @import statements at the top of the file
-      # Per CSS spec, @import must come before all rules except @charset
-      imports = extract_imports(css)
-
-      return css if imports.empty?
-
-      # Process each import
-      resolved_css = +'' # Mutable string
-      remaining_css = css
-
-      imports.each do |import_data|
-        url = import_data[:url]
-        media = import_data[:media]
-
-        # Validate URL
-        validate_url(url, opts)
-
-        # Check for circular references
-        raise ImportError, "Circular import detected: #{url}" if imported_urls.include?(url)
-
-        # Fetch imported CSS using the fetcher
-        imported_css = fetcher.call(url, opts)
-
-        # Recursively resolve imports in the imported CSS
-        imported_urls_copy = imported_urls.dup
-        imported_urls_copy << url
-        imported_css = resolve(imported_css, opts, depth: depth + 1, imported_urls: imported_urls_copy)
-
-        # Wrap in @media if import had media query
-        imported_css = "@media #{media} {\n#{imported_css}\n}" if media
-
-        resolved_css << imported_css << "\n"
-
-        # Remove this import from remaining CSS
-        remaining_css = remaining_css.sub(import_data[:full_match], '')
-      end
-
-      # Return resolved imports + remaining CSS
-      resolved_css + remaining_css
-    end
-
     # Normalize options with safe defaults
     def self.normalize_options(options)
       if options == true
@@ -151,27 +82,27 @@ module Cataract
       end
     end
 
-    # Extract @import statements from CSS
-    # Returns array of hashes: { url: "...", media: "...", full_match: "..." }
-    # Delegates to C implementation for performance
-    def self.extract_imports(css)
-      Cataract.extract_imports(css)
-    end
-
     # Normalize URL - handle relative paths and missing schemes
     # Returns a URI object
-    def self.normalize_url(url, base_path = nil)
+    #
+    # @param url [String] URL to normalize
+    # @param base_path [String, nil] Base path for resolving relative file imports
+    # @param base_uri [String, nil] Base URI for resolving relative HTTP imports
+    def self.normalize_url(url, base_path: nil, base_uri: nil)
       # Try to parse as-is first
       uri = URI.parse(url)
 
-      # If no scheme, treat as relative file path
+      # If no scheme, treat as relative path
       if uri.scheme.nil?
-        # Convert to file:// URL
-        # Relative paths stay relative, absolute paths stay absolute
-        if url.start_with?('/')
+        # If we have a base_uri (HTTP/HTTPS), resolve against it
+        if base_uri
+          base = URI.parse(base_uri)
+          uri = base.merge(url)
+        elsif url.start_with?('/')
+          # Absolute file path
           uri = URI.parse("file://#{url}")
         else
-          # Relative path - make it absolute relative to base_path or current directory
+          # Relative file path - make it absolute relative to base_path or current directory
           absolute_path = if base_path
                             File.expand_path(url, base_path)
                           else
@@ -188,7 +119,7 @@ module Cataract
 
     # Validate URL against security options
     def self.validate_url(url, options)
-      uri = normalize_url(url, options[:base_path])
+      uri = normalize_url(url, base_path: options[:base_path], base_uri: options[:base_uri])
 
       # Check scheme
       unless options[:allowed_schemes].include?(uri.scheme)