[robobun]

Problem

• .x{color:var(--c,lab(50% 20 30));color:red} builds to .x{color:red} and two @supports rules with copies of the first declaration. They follow the rule, so that declaration wins.
• add_unparsed_fallbacks (src/css/context.rs:310) stages a copy per color tier, and minify_style_arm prints them behind the rule.

Fix

• A later declaration of the same property drops the staged copies: a typed color or text-shadow that every target accepts, a value with var(), or inherit, initial, unset, revert.
• The drop reads only the copies staged since that property's first copy.
• An ignored rule follows a rule that lost each copy, so the next rule stays apart (second commit).
• Verified: 54 new tests in test/js/bun/css/css.test.ts, 36 fail on main. Self-reviewed: 8 concerns raised, 2 addressed, the ignored rule is open (Notes).

Background

• A var() value with a color wider than sRGB prints in sRGB. @supports rules behind the rule hold a copy per tier (P3, LAB).
• CssRuleList::minify merges a rule into the style rule before it. The printer skips CssRule::Ignored, a non-style rule.
• Weighed: a merge-state flag (lost when a merged @media list is minified again), a rule cut at the later declaration (Notes).

Notes

A decision for a maintainer: the ignored rule. On main the @supports rules sit behind the style rule, so the next rule never merges into it. Without them it does, and that merge has faults on main, with no color involved:

• .x{padding:1px}.x{all:unset} prints all:unset first (css: make the all shorthand reset the declarations before it #42042).
• .x{width:100%}.x{width:var(--w)} prints width:var(--w) first (css: keep an unparsed width/height/color after the declarations written before it #42101).
• .b{color:var(--c,#a16945)}.a{color:var(--c,lab(50% 20 30))} merges the selectors and prints the copies with an empty selector (css: keep the selectors on rules added for color fallbacks and logical properties #43240).

The second commit pushes a CssRule::Ignored behind a rule that lost each copy. CssRuleList::minify passes it through as a non-style rule, also when two @media rules with one query merge and their rules are minified again. So each output of this PR is the output of main without the dropped copies.

The self-review prefers the other order: no ignored rule, and this PR lands after #42042, #42101 and #43240, because the faults belong to the merge. That is this PR without its second commit. Without that commit, .x{color:var(--c,lab(50% 20 30));color:red}.x{all:unset;color:var(--z)} ends in color:var(--z);all:unset until #42042 lands. Say which one you want and I will leave only that. If the ignored rule stays, it can go when the merge faults are fixed.

Why those values. A browser that reads a copy must keep the later declaration at parse time. If it drops the declaration, the copy is the right winner.

• var(), inherit, initial, unset and revert are older than color() and lab() in each browser (caniuse-lite 1.0.30001636: revert is Chrome 84, Firefox 67, Safari 9.1, and color(display-p3) is Safari 10.1, Chrome 111, Firefox 113).
• env() does not count: Safari reads it from 11.1. revert-layer does not count: Safari reads it from 15.4.
• An empty var() fallback does not count. WebKit rejected it until r279358 (bug 227368, June 2021), so Safari 14, a default target of bun build, reads a P3 copy and drops color:var(--d,).
• A var() fallback with ; or ! at its top level is not a <declaration-value>, and the name -- is reserved. No browser keeps those.
• The parser keeps VAR() and ENV() as plain functions, so a value with one does not count.

The report. It has five rules. On main the copies of the first declaration win in all five. With this PR they win in two.

rule	main	this PR
.x{color:var(--c,lab(50% 20 30));color:red}	copies win	.x{color:red}
.x{color:var(--c,lab(50% 20 30));color:var(--d)}	copies win	.x{color:var(--d)}
.x{color:var(--c,lab(50% 20 30));color:inherit}	copies win	.x{color:inherit}
.x{background-color:var(--bg,oklch(70% 0.1 200));background:none}	copies win	as on main
.x{border-color:var(--b,oklch(70% 0.1 200));border:0}	copies win	as on main

What the drop does. A later declaration drops every staged copy of its property that has the same importance, then stages its own copies. .x{color:var(--c,lab(50% 20 30));color:var(--d,oklch(70% .1 200))} printed both copies in each @supports rule. It now prints the copy of --d only, which won there before too.

The bound. Each declaration adds at most one copy to a list. staged counts the declarations of the rule that staged a copy, and Copied.since holds that count at the first copy of a property and importance. The drop reads the last staged - since copies of each list. An entry that lost each copy stays in place, so the order of the P3 rule and the LAB rule does not depend on a drop.

A rule with nested rules. Main splits such a rule in two around its @supports rules. A rule that lost each copy is not split. It prints as main prints a rule that never had copies.

What is not in this PR. A first version also cut the style rule in front of a later declaration that only competes with a copy: a shorthand after a copied longhand, a longhand after a copied shorthand, all, and a value that a target can reject. It fixes the last two rules of the table. A review of that version asked for this split:

• The cut is about 440 source lines and no maintainer has agreed to the mechanism.
• The output grows with selectors times cuts. 200 selectors with 200 cuts are 11.7 KB in and 692 KB out, and 25 KB on main.
• It overlaps css: keep the selectors on rules added for color fallbacks and logical properties #43240, css: keep an unparsed width/height/color after the declarations written before it #42101, css: make the all shorthand reset the declarations before it #42042 and css: keep declarations written after a nested rule in their cascade position #38539.

The branch is robobun/e2586397/css-supports-copies-order. A smaller next step is a drop in the typed arms of the background, border and box-shadow handlers.

The typed rule trusts the compat table. Where the table has a hole (a system color other than AccentColor, the units rex, rch, ric, rcap), main already drops the earlier declaration from the rule, and this PR drops its copies too.

Reviews. A review of the first push found that the drop scanned every staged copy (one rule with 20,000 staged copies and 20,000 replaced declarations took 3.4 s), that a dropped entry could flip the order of the two @supports rules, and that the next rule merged into the rule. All three are fixed. The self-review of this push raised 8 concerns:

• Fixed: a var() fallback with ; or ! counted as valid. The ignored rule had no removal condition in the tree, and the comment now names css: make the all shorthand reset the declarations before it #42042 and css: keep an unparsed width/height/color after the declarations written before it #42101.
• Open: the ignored rule works around faults of the merge (the decision above). css: emit the color-scheme fallback vars once when a block is minified again #38512 makes a second minify skip ignored rules, which would undo it inside merged @media rules.
• Stated: the next rule does not merge (Downsides), the typed drop covers one of the five handlers that stage copies (Downsides), css: keep an unparsed width/height/color after the declarations written before it #42101 changes the expected output of rows that hold two unparsed declarations, and the fault reaches one daisyUI rule today.

Fuzz. Main against this build.

• A cascade model with three browser classes (sRGB, P3, P3 and LAB) over 380,000 sheets in seven shapes, default targets of bun build: 0 sheets go from right to wrong, 54,195 go from wrong to right.
• 300,000 flat sheets with the default targets and 60,000 single rules over ten target sets: each output is the output of main with declarations removed from generated @supports rules, and nothing else.
• 40,000 nested sheets over ten target sets: 21,567 differ by dropped copies only. 258 print the same rules in another order and 54 keep a rule that main removes as a duplicate, both through the unsplit rule above.
• Debug build with ASAN: 40,000 of these sheets, no report, output equal to the release build.

Other open PRs and upstream. lightningcss 1.33.0 prints the same two @supports rules for the first rule of the table. The ltr and rtl rules of logical properties (#38623) and the dark rules of light-dark() have the same order fault and are not changed. lightningcss has an open PR, parcel-bundler/lightningcss#1287, that adds remove_conditional_property in the same shape for custom properties. This fault is not reported upstream yet.

Measurements. Release builds of main 5866b5f and of this PR with one toolchain. The container has no perf and no valgrind. Each count is a gdb single-step count or a gdb breakpoint hit count.

Instructions per minify_style_arm call (one style rule, with its declarations):

rule	main	this PR
.x{margin:0;padding:0}	4,937	4,942
.x{color:red;color:blue}	4,152	4,158
.x{color:var(--c);color:var(--d)}	4,748	4,761
.x{color:var(--c,lab(50% 20 30))}, first rule of a sheet that stages a copy	13,865	13,973
the same rule as the second and third rule of the sheet	10,808 and 11,214	10,830 and 11,236
.x{color:var(--c,lab(50% 20 30));color:red}	14,195	11,069
.x{color:var(--c,lab(50% 20 30));color:var(--d)}	14,511	11,437

• The 15 sheets in test/js/bun/css/files: 20,780 rules and 4,120 add_unparsed_fallbacks calls on both. The three new functions are entered 0 times. The counted allocator entry points are hit 77,533 times on both. The output is byte-identical for 15 of 15.
• daisyUI 5.7.47 daisyui.css: 2,580,870 to 2,579,118 bytes. The 12 dead @supports rules of the 6 ::picker(select) rules are gone (74 to 62 generated rules), and nothing else changes. Allocations 111,937 to 111,836.
• Time for one rule, N = 5,000, 10,000 and 20,000, median of five runs:

rule	main	this PR
N pairs color:var(--c,lab(50% 20 30));color:red	16, 31, 72 ms	10, 19, 39 ms
N box-shadow:foo(Npx lab(50% 20 30)), which all stay staged, then N such pairs	36, 79, 181 ms	29, 66, 138 ms
the same N copies, then N color:var(--cN,lab(50% 20 30))	38, 80, 149 ms	32, 61, 123 ms
a staged copy, then a pair, N times	43, 86, 182 ms	34, 71, 143 ms
ten properties get a copy, N copies follow, each of the ten is replaced	24, 47, 90 ms	24, 47, 93 ms

• Release binary: .text 81,071,045 to 81,074,629 bytes (size -A), +3,584. The file is one page larger, +4,096 bytes.

Suites. Debug build: css.test.ts 1,368 pass, 69 skip, 3 todo, 0 fail. Release build of this branch: 2,754 pass, 69 skip, 3 todo, 0 fail in the 29 files of test/js/bun/css/ and test/bundler/css/, and 56 pass, 1 todo in test/bundler/esbuild/css.test.ts.

Downsides

• Not fixed: a typed background, border, box-shadow or light-dark() value, a shorthand after a copied longhand, all, text-shadow:none.
• The next rule does not merge into a rule that lost its copies, as on main.
• +5 instructions per style rule, +13 per declaration that stages copies. .text +3,584 bytes.

---

[human-review] gate passed · iteration 0 · 5 files touched

fails on main (without fix)

ASAN without fix: 36 failed, 72 skipped
$ BUN_DEBUG_QUIET_LOGS=1 bun scripts/build.ts --profile=debug --quiet test "--reporter=junit" "--reporter-outfile=/tmp/pr_gate.xml" test/js/bun/css/css.test.ts
bun test v1.4.4 (367d939d9)

test/js/bun/css/css.test.ts:
Output .flexrow {
  flex-direction: row;
}

.flexcol {
  flex-direction: column;
}

.hello {
  flex-wrap: wrap;
}

.world {
  flex-wrap: nowrap;
}

(pass) css tests > .flexrow {
	flex-direction: row;
}

.flexcol {
	flex-direction: column;
}

.hello {
	flex-wrap: wrap;
}

.world {
	flex-wrap: nowrap;
} [4.94ms]
Output .foo {
  content: "+";
}

(pass) css tests > .foo {
  content: "\2b";
} [1.03ms]
Output div {
  --foo: 1 1 1 #0101011a, 2 2 2 #02020233;
  --bar: 1 1 1 #01010116, 2 2 2 #02020233;
}

(pass) css tests > custom property cases > div {
        --foo: 1 1 1 rgba(1, 1, 1, 0.1), 2 2 2 rgba(2, 2, 2, 0.2);
        --bar: 1 1 1 #01010116, 2 2 2 #02020233;
      } [0.98ms]
Output :root {
  --my-color: red;
  --my-bg: white;
  --my-font-size: 16px;
}

.element {
  color: var(--my-color);
  background-color: var(--my-bg);
  font-size: var(--my-font-size);
}

(pass) css tests > custom property cases > :root {
        --my-color: red;
        --my-bg: wh
... (truncated)

release without fix: 60 failed, 72 skipped
bun test v1.4.3-canary.1 (367d939d9)

test/js/bun/css/css.test.ts:
Output .flexrow {
  flex-direction: row;
}

.flexcol {
  flex-direction: column;
}

.hello {
  flex-wrap: wrap;
}

.world {
  flex-wrap: nowrap;
}

(pass) css tests > .flexrow {
	flex-direction: row;
}

.flexcol {
	flex-direction: column;
}

.hello {
	flex-wrap: wrap;
}

.world {
	flex-wrap: nowrap;
} [0.78ms]
Output .foo {
  content: "+";
}

(pass) css tests > .foo {
  content: "\2b";
} [0.21ms]
Output div {
  --foo: 1 1 1 #0101011a, 2 2 2 #02020233;
  --bar: 1 1 1 #01010116, 2 2 2 #02020233;
}

(pass) css tests > custom property cases > div {
        --foo: 1 1 1 rgba(1, 1, 1, 0.1), 2 2 2 rgba(2, 2, 2, 0.2);
        --bar: 1 1 1 #01010116, 2 2 2 #02020233;
      } [0.06ms]
Output :root {
  --my-color: red;
  --my-bg: white;
  --my-font-size: 16px;
}

.element {
  color: var(--my-color);
  background-color: var(--my-bg);
  font-size: var(--my-font-size);
}

(pass) css tests > custom property cases > :root {
        --my-color: red;
        --my-bg: white;
        --my-font-size: 16px;
      }
      .element {
        color: var(--my-color);
        background-color: var(--my-bg);
        font-size: 
... (truncated)

passes on PR (with fix)

ASAN with fix: 72 skipped
$ BUN_DEBUG_QUIET_LOGS=1 bun scripts/build.ts --profile=debug --quiet test "--reporter=junit" "--reporter-outfile=/tmp/pr_gate.xml" test/js/bun/css/css.test.ts
rustup spent 7s installing the pinned toolchain (nightly-2026-09-15); it was missing or incomplete on this machine
bun test v1.4.4 (367d939d9)

test/js/bun/css/css.test.ts:
Output .flexrow {
  flex-direction: row;
}

.flexcol {
  flex-direction: column;
}

.hello {
  flex-wrap: wrap;
}

.world {
  flex-wrap: nowrap;
}

(pass) css tests > .flexrow {
	flex-direction: row;
}

.flexcol {
	flex-direction: column;
}

.hello {
	flex-wrap: wrap;
}

.world {
	flex-wrap: nowrap;
} [8.64ms]
Output .foo {
  content: "+";
}

(pass) css tests > .foo {
  content: "\2b";
} [15.70ms]
Output div {
  --foo: 1 1 1 #0101011a, 2 2 2 #02020233;
  --bar: 1 1 1 #01010116, 2 2 2 #02020233;
}

(pass) css tests > custom property cases > div {
        --foo: 1 1 1 rgba(1, 1, 1, 0.1), 2 2 2 rgba(2, 2, 2, 0.2);
        --bar: 1 1 1 #01010116, 2 2 2 #02020233;
      } [2.64ms]
Output :root {
  --my-color: red;
  --my-bg: white;
  --my-font-size: 16px;
}

.element {
  color: var(--my-color);
  background-color: var(--my-bg);
  font-size: var
... (truncated)

release with fix: 72 skipped
$ bun scripts/build.ts --profile=release
rustup spent 9s installing the pinned toolchain (nightly-2026-09-15); it was missing or incomplete on this machine
[configured] bun-profile → bun (stripped)
  target       linux-x64-gnu
  build type   Release
  build dir    ./build/release
  revision     56c23fe12f
  features     lto, baseline

23 deps, 204 codegen, 1207 objects in 17513ms

ninja: Entering directory `/workspace/bun/build/release'
[1/4] fetch rust-argon2
[rust-argon2] up to date
[2/4] fetch lolhtml
[lolhtml] up to date
[2/4] cargo plan → /workspace/bun/build/release/rust-target/plan.json
268 units: 194 lib, 16 proc-macro (host), 20 custom-build (host), 16 run custom-build, 17 lib (host), 4 run custom-build (host), 1 rlib
[3/4] reconfigure
[1/1564] mkdir stamps
[2/1564] mkdir codegen
[3/1564] gen bake.{client,server,error}.js
-> bake.client.js, bake.server.js, bake.error.js
[4/1564] install /workspace/bun
bun install v1.4.3-canary.1 (367d939d9)

Checked 22 installs across 44 packages (no changes) [8.07s]
[5/1564] install /workspace/bun/packages/bun-error
bun install v1.4.3-canary.1 (367d939d9)

Checked 1 install across 2 packages (no changes) [688.00ms]
[6/
... (truncated)

diff hotspot

src/css/context.rs                   |  94 +++++++++++++++++
 src/css/properties/custom.rs         |  54 ++++++++++
 src/css/properties/prefix_handler.rs |   3 +
 src/css/rules/mod.rs                 |   8 ++
 test/js/bun/css/css.test.ts          | 192 +++++++++++++++++++++++++++++++++++
 5 files changed, 351 insertions(+)

gate history · 1 passed · 0 rejected · iteration 0

evidence per changed file

file                                  reads  edits  tests
src/css/context.rs                        2      0    117
src/css/properties/custom.rs              0      0    115
src/css/properties/prefix_handler.rs      0      0    115
src/css/rules/mod.rs                      3      0    116
test/js/bun/css/css.test.ts               2      1    115

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

• Configuration used: Repository: oven-sh/bun/.coderabbit.yaml
• Review profile: ASSERTIVE
• Plan: Advanced
• Run ID: 3d5e7ee1-afd3-4a11-b410-a5bede29ab5c

📥 Commits

Reviewing files that changed from the base of the PR and between 5866b5f and d890fd9.

📒 Files selected for processing: 5

• src/css/context.rs
• src/css/properties/custom.rs
• src/css/properties/prefix_handler.rs
• src/css/rules/mod.rs
• test/js/bun/css/css.test.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 4 remain after this review.

Walkthrough

The CSS minifier now tracks generated @supports fallback copies by property and importance. It removes matching copies when a later value is valid at parse time, and adjusts style-rule output after retraction.

Changes

CSS conditional fallback retraction

Layer / File(s)	Summary
Validate values and track conditional copies src/css/properties/custom.rs, src/css/context.rs	TokenList checks whether values are valid at parse time. PropertyHandlerContext tracks staged fallbacks and retracts matching copies when a valid replacement is processed.
Integrate retraction with style-rule output src/css/properties/prefix_handler.rs, src/css/context.rs, src/css/rules/mod.rs, test/js/bun/css/css.test.ts	Property replacement triggers retraction. Empty @supports entries are omitted, and style-rule processing uses the retraction state. Tests cover removal and preservation of copies, rule ordering, and style-rule merging.

Suggested reviewers: jarred-sumner

Priority: ➖ Normal

Merge Risk: ⚪ Minimal · up to d890f

The minifier now removes @supports color fallback copies when a later declaration of the same property replaces them. This fixes output where stale fallbacks overrode the later value. The changes are narrowly scoped and covered by new tests for removal, preservation, ordering, and rule merging. No merge-blocking issues were found.

Pre-merge checks: 4

Check name	Status	Explanation
Linked Issues check		Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check		Check skipped because no linked issues were found for this pull request.
Title check		The title clearly and concisely describes the main change: removing replaced @supports color fallback copies.
Description check		The description is complete and relevant. It explains the problem, the fix, known limitations, design decisions, performance impact, and verification results. It does not use the template headings exa…

Full details: Description check

Explanation

The description is complete and relevant. It explains the problem, the fix, known limitations, design decisions, performance impact, and verification results. It does not use the template headings exactly, but it provides the required information in equivalent sections.

✨ Finishing Touches: 💡 1

🛠️ Fix failing CI checks: 💡

• Commit to this branch
• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[robobun]

^{Updated 7:05 PM PT - Oct 19th, 2026}

❌ @robobun, your commit 56c23fe has 1 failures in Build #129081 (All Failures):

• test/cli/bake/bake.test.ts - code 1 on 🪟 2019 x64

---

🧪   To try this PR locally:

bunx bun-pr 45560

That installs a local version of the PR into your bun-45560 executable, so you can run:

bun-45560 --bun

[robobun]

Reproduced on main 5866b5f and on the 1.4.2 release, before the change:

$ printf '.x{color:var(--c,lab(50%% 20 30));color:red}' > a.css && bun build --minify a.css
.x{color:red}@supports (color:color(display-p3 0 0 0)){.x{color:var(--c,color(display-p3 .598686 .422118 .293048))}}@supports (color:lab(0% 0 0)){.x{color:var(--c,lab(50% 20 30))}}

With this PR the output is .x{color:red}.

The tests are in test/js/bun/css/css.test.ts (block "@supports color fallbacks and a later declaration of the same property"). 36 of the 54 fail on main.

CI on the diff is green: 180 of the 181 jobs of build #129081 pass, on Linux, Windows and macOS. The one red test is test/cli/bake/bake.test.ts on Windows 2019 x64 (ECONNREFUSED from the bake server in "bun --check bake starts the server once the type errors are fixed"). This PR does not touch it. The red tests of the build before (#128173) were install, module graph, node:http and worker tests, and they pass in #129081.

[claude]

Beyond the inline findings, I also checked the !important tier split in retract_conditional (a non-important later declaration only touches entry.declarations, so !important copies survive, and the copied bookkeeping scans both tiers before dropping the id) and the copied lifecycle (initialised in new/child, cleared in the reset path alongside supports) — neither showed a problem.

Extended reasoning...

The change adds a copied: Vec<PropertyId> field and two cold retraction methods to the CSS minifier's PropertyHandlerContext, wires the typed FallbackHandler arm to call one of them, adds TokenList::is_valid_at_parse_time in custom.rs, and adds 38 tests. It touches no security-sensitive surface. The inline findings include a confirmed behavioral regression from same-selector rule merging and several partial-fix gaps across sibling handlers, and the hunt stopped at its bug cap, so a human maintainer should weigh the design before this merges.

Findings marked 🟡 are optional suggestions and need no follow-up push.

[claude]

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

The two newest commits address the merge-reorder, bounded-retraction, revert, and exact-assertion points from my earlier review. Beyond the inline finding, I also checked that the re-minify of a previously merged block (which runs with DeclarationContext::None while the next rule's copies are staged) cannot retract those copies — add_unparsed_fallbacks returns early and retract_conditional is gated on StyleRule — and that the recent = staged - since window is sound, since every push into a SupportsEntry list goes through add_unparsed_fallbacks, which bumps staged. The new CssRule::Ignored barrier in minify_style_arm mirrors the existing non-style-rule arm, and the style_rules index map tolerates it the same way it tolerates the appended @ supports rules.

Extended reasoning...

The change adds a per-rule ledger of copied properties to PropertyHandlerContext, a retraction hook in FallbackHandler, three token-list predicates in custom.rs, and a merge barrier in rules/mod.rs, with 38 new exact-output test rows; it touches no security-sensitive surface. It is a cascade-semantics change in the CSS minifier with a merge-state interaction, so a human maintainer should still weigh the mechanism, and the typed background/border/box-shadow arms and shorthand/longhand cases remain unhandled by the author's own account.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

• 🟣 src/css/rules/mod.rs — pre-existing: when a rule that still has staged @ supports copies merges its selectors into the previous rule, the copies are printed with an empty selector, invalid CSS that P3/LAB browsers drop. The selector merge in merge_style_rules takes sty.selectors.v (src/css/rules/mod.rs:1179) before get_supports_rules clones them at src/css/rules/mod.rs:774, so the copy rule becomes @ supports (...){{color:...}}. The new Ignored barrier at src/css/rules/mod.rs:899 only covers the retracted case. Fix: build the @ supports and logical extras from the selectors as they were before the merge (snapshot like incompatible_decls at mod.rs:713), or skip the selector merge while the handler context has staged supports/ltr/rtl/dark entries.

  Why this was flagged

  Input .x{color:var(--c,#a16945)}.y{color:var(--c,lab(50% 20 30))} minified with the test targets (chrome 87, safari 14). .y minifies to color:var(--c,#a16945) and stages P3 and LAB copies in src/css/context.rs:356. At src/css/rules/mod.rs:723-742 merge_style_rules finds the declarations equal (mod.rs:1158) and moves .y into the previous rule with core::mem::take(&mut src.selectors.v) at mod.rs:1179. get_supports_rules at mod.rs:774 then deep-clones the now-empty style_rule.selectors (src/css/context.rs:158) and mod.rs:881 appends @ supports (color:color(display-p3 0 0 0)){{color:var(--c,color(display-p3 ...))}} with no selector. The user gets .x,.y{color:var(--c,#a16945)} followed by selector-less @ supports blocks that browsers reject, so .y never gets its wide-gamut color. The base branch prints the same; the diff's barrier at mod.rs:899 fires only when retracted is set.

  Verification: pre-existing. merge_style_rules at src/css/rules/mod.rs:1158 finds equal declarations and at mod.rs:1179 does core::mem::take(&mut src.selectors.v), emptying .y's selector list. Only afterwards does mod.rs:774 call get_supports_rules, which clones the now-empty selectors at context.rs:158. The new barrier at mod.rs:898-903 is gated on retracted, so it does not fire here.

[robobun]

The empty selector after a selector merge is on main too, with no copies dropped: .x{color:var(--c,#a16945)}.y{color:var(--c,lab(50% 20 30))} prints the same there. #43240 (open) keeps the selectors on these rules, so this PR does not change it. The ignored rule only keeps a rule that lost its copies out of that merge, so that this PR does not add a new way into the fault.

[Jarred-Sumner]

Part of this landed in #47025 (7942008). Its description says what was taken.

A later declaration of a property drops the @supports color copies of the earlier one, which printed after the rule and won. 2 real stylesheets

[robobun]

Verified on main at 7942008: .x{color:var(--c,lab(50% 20 30));color:red} prints .x{color:red}, and the var(--d) and inherit forms print without the copies too.

One difference from this PR, for the record. The drop that landed runs for each later unparsed declaration, with no test for whether a browser keeps that declaration. So .x{color:var(--c,lab(50% 20 30));color:var(--d,)} now prints .x{color:var(--d,)} with no copies. WebKit rejected an empty var() fallback until r279358 (bug 227368, June 2021), so Safari 14, a default target, drops that declaration and used the P3 copy before. I expect no real stylesheet has this shape, so I am not opening a PR for it.