[robobun]

Problem

• @scope output does not match css-cascade-6 or Chrome. .p { @scope (.a) { span {} } } compiles to @scope (.a) { :scope span {} } and styles .a outside .p. @scope (.a) { & .c {} } compiles to :scope .c, which adds specificity. @scope (.a) { > .c {} } and @scope (.a) { color: red } fail the build with Invalid selector. Empty selector is not allowed and Unexpected end of input. Details and the Chrome comparison: css: @scope in a style rule, and relative selectors, declarations and invalid selectors in @scope, print wrong or fail to parse #43143.
• Cause: the parser treats an @scope block like a @media block (NestedRuleParser::parse_prelude, src/css/css_parser.rs). Inside a style rule every nested selector gets &, at the top level no relative selector or declaration is allowed. The printer compiles a context-less & to :scope (serialize_nesting, src/css/selectors/selector.rs).

Fix

• NestedRuleParser gets is_in_scope_rule. Style rules in an @scope parse with the new NestingRequirement::Scoped: a leading combinator is anchored to &, a plain selector gets no prefix. Declarations in the block go into a & { } rule, as in a nested @media.
• An @scope in a style rule parses its scope-start selector with NestingRequirement::Implicit, so .p { @scope (.a) } compiles to @scope (.p .a) and (> .a) to (.p > .a).
• Printer::in_scope_rule is set while the scope-end selector and the block print. There a context-less & compiles to :where(:scope). Both selector lists of the prelude use ParseErrorRecovery::DiscardList, so an invalid selector rejects the rule ([css-cascade-6] Should @scope's <scope-start> & <scope-end> be unforgiving? w3c/csswg-drafts#10042). This is the one breaking change: @scope (.a) to (.b, !!!) used to print to (.b).
• Verified: test/js/bun/css/css.test.ts (describe("scope"), 30 new tests, all fail on the base). Also test/bundler/css/, test/bundler/esbuild/css.test.ts, and the test/js/bun/css/ nesting and loader suites.

Background

• @scope (<scope-start>) to (<scope-end>) { ... } applies its rules below each element that matches scope-start (the scoping root), and stops at each element that matches scope-end.
• Scoped style rules take a relative selector list (> .c). & in them is the scoping root, and behaves as :where(:scope): it matches :scope with no specificity.
• When the targets have no CSS nesting (the bun build default), the printer replaces & with the parent selector. With no parent, it printed :scope.
• This PR is stacked on css: stop truncating @scope to (...) and stop replacing & in the scope-end selector #43146, which prints the scope-end selector with no parent context. It re-pins the scope-end rows of that PR to :where(:scope), so one form covers the prelude and the block.

Notes

Item 7 of #43143 (&div printed as written when nesting is kept) is not in this PR. #43047 rewrites the block of serialize_selector that decides the &div to div& swap, so that change belongs there or after it.

Nested @scope in @scope: the inner scope-start parses with no implicit prefix, as a scoped rule. A & in it compiles to :where(:scope), the outer scoping root.

The shallow nesting spanning @scope test in nested-selector-list-expansion.test.ts asserted that rules in a nested @scope print :scope. It now asserts the scoped output.

Output of the issue cases with this branch, minified. "kept": no targets. "compiled": Chrome 95 targets.

Source	kept	compiled
.p { @scope (.a) { span {} } }	.p{@scope(& .a){span{}}}	@scope (.p .a) { span {} }
.p { @scope (> .a) { span {} } }	.p{@scope(&>.a){span{}}}	@scope (.p > .a) { span {} }
.p { @scope (.a) { :scope > .c {} } }	.p{@scope(& .a){:scope>.c{}}}	@scope (.p .a) { :scope > .c {} }
@scope (.a) { & .c {} }	unchanged	@scope (.a) { :where(:scope) .c {} }
@scope (.a) { > .c {} }	@scope(.a){&>.c{}}	@scope (.a) { :where(:scope) > .c {} }
@scope (.a) { color: red }	@scope(.a){&{color:red}}	@scope (.a) { :where(:scope) { color: red } }
@scope (.a) to (.b, !!!) { .c {} }	error	error

Self-reviewed before opening. The review asked for the stack on #43146, for one & form across prelude and block, and to leave item 7 to #43047.

---

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

fails on main (without fix)

ASAN without fix: 44 failed, 67 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 test/js/bun/css/nested-selector-list-expansion.test.ts
bun test v1.4.3 (c6b7fcb5b)

test/js/bun/css/nested-selector-list-expansion.test.ts:
(pass) deeply nested multi-selector rules error instead of exploding when compiled for old targets [38.79ms]
(pass) deeply nested ::part() selector lists error instead of exploding when compiled for old targets [12.49ms]
(pass) nested rules below the expansion limit still compile for old targets [37.35ms]
(pass) the fuzzer reproduction still minifies when no targets are configured [11.54ms]
(pass) deep nesting is preserved as-is for targets that support CSS nesting [13.25ms]
(pass) incompatible selector lists that collapse into :is() don't hit the limit when nesting is preserved [8.89ms]
(pass) collapsed :is() lists still hit the limit when nesting has to be compiled away [9.17ms]
(pass) bun build reports an error instead of exploding on deeply nested multi-selector css [361.02ms]
(pass) nested multi-selector rules spanning @starting-style error instead of exploding (mini
... (truncated)

release without fix: 1 failed, 67 skipped
bun test v1.4.3-canary.1 (fd45ac41d)

test/js/bun/css/nested-selector-list-expansion.test.ts:
(pass) deeply nested multi-selector rules error instead of exploding when compiled for old targets [0.27ms]
(pass) deeply nested ::part() selector lists error instead of exploding when compiled for old targets [0.10ms]
(pass) nested rules below the expansion limit still compile for old targets [0.48ms]
(pass) the fuzzer reproduction still minifies when no targets are configured [0.14ms]
(pass) deep nesting is preserved as-is for targets that support CSS nesting [0.11ms]
(pass) incompatible selector lists that collapse into :is() don't hit the limit when nesting is preserved [0.07ms]
(pass) collapsed :is() lists still hit the limit when nesting has to be compiled away [0.08ms]
(pass) bun build reports an error instead of exploding on deeply nested multi-selector css [11.48ms]
(pass) nested multi-selector rules spanning @starting-style error instead of exploding (minify) [0.26ms]
(pass) nested multi-selector rules spanning @starting-style error instead of exploding (prefix) [0.09ms]
(pass) nested multi-selector rules spanning @starting-style error instead of exploding [0.08ms
... (truncated)

passes on PR (with fix)

ASAN with fix: 67 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 test/js/bun/css/nested-selector-list-expansion.test.ts
bun test v1.4.3 (c6b7fcb5b)

test/js/bun/css/nested-selector-list-expansion.test.ts:
(pass) deeply nested multi-selector rules error instead of exploding when compiled for old targets [15.64ms]
(pass) deeply nested ::part() selector lists error instead of exploding when compiled for old targets [17.16ms]
(pass) nested rules below the expansion limit still compile for old targets [21.76ms]
(pass) the fuzzer reproduction still minifies when no targets are configured [7.90ms]
(pass) deep nesting is preserved as-is for targets that support CSS nesting [8.50ms]
(pass) incompatible selector lists that collapse into :is() don't hit the limit when nesting is preserved [5.37ms]
(pass) collapsed :is() lists still hit the limit when nesting has to be compiled away [5.50ms]
(pass) bun build reports an error instead of exploding on deeply nested multi-selector css [327.67ms]
(pass) nested multi-selector rules spanning @starting-style error instead of exploding (minify
... (truncated)

release with fix: 67 skipped
$ bun scripts/build.ts --profile=release
[configured] bun-profile → bun (stripped) in 707ms (unchanged)
ninja: Entering directory `/workspace/bun/build/release'
[0/7] cargo bun_runtime → libbun_runtime.a
�[1m�[33mwarning�[0m�[1m: binary `bun_shim_impl` should have a kebab-case name�[0m
   �[1m�[94m|�[0m
�[1m�[94m 1�[0m �[1m�[94m|�[0m /workspace/bun/build/release/rust-target/.../bun_shim_impl
   �[1m�[94m|�[0m                                              �[1m�[33m^^^^^^^^^^^^^�[0m
   �[1m�[94m|�[0m
   �[1m�[94m= �[0m�[1mnote�[0m: `cargo::non_kebab_case_bins` is set to `warn` by default
�[1m�[96mhelp�[0m: to change the binary name to `bun-shim-impl`, convert `bin.name`
  �[1m�[94m--> �[0msrc/install/windows-shim/Cargo.toml:41:8
   �[1m�[94m|�[0m
�[1m�[94m41�[0m �[91m- �[0mname = �[91m"bun_shim_impl"�[0m
�[1m�[94m41�[0m �[92m+ �[0mname = �[92m"bun-shim-impl"�[0m
   �[1m�[94m|�[0m
�[1m�[33mwarning�[0m: `bun_shim_impl` (manifest) generated 1 warning
�[1m�[92m   Compiling�[0m bun_core v0.0.0 (/workspace/bun/src/bun_core)
�[1m�[92m   Compiling�[0m bun_errno v0.0.0 (/workspace/bun/src/errno)
�[1m�[92m   Compiling�[0m bun_ptr v0.0.0 (/workspace/bun/src/ptr)
�[1m�[92m   C
... (truncated)

diff hotspot

src/css/css_parser.rs                              |  61 ++++++++--
 src/css/printer.rs                                 |   3 +
 src/css/rules/scope.rs                             |  46 ++++----
 src/css/selectors/parser.rs                        |   7 +-
 src/css/selectors/selector.rs                      |  11 +-
 test/js/bun/css/css.test.ts                        | 125 ++++++++++++++++++---
 .../bun/css/nested-selector-list-expansion.test.ts |   7 +-
 7 files changed, 199 insertions(+), 61 deletions(-)

gate history · 2 passed · 0 rejected · iteration 0

evidence per changed file

file                                                    reads  edits  tests
src/css/css_parser.rs                                       8     10     31
src/css/printer.rs                                          2      2     31
src/css/rules/scope.rs                                      2      2     31
src/css/selectors/parser.rs                                 3      2     31
src/css/selectors/selector.rs                               3      1     32
test/js/bun/css/css.test.ts                                 4      5     30
test/js/bun/css/nested-selector-list-expansion.test.ts      1      2      8

[robobun]

^{Updated 5:05 PM PT - Sep 17th, 2026}

❌ @robobun, your commit a450bd1 has some failures in Build #117327 (All Failures)

---

🧪   To try this PR locally:

bunx bun-pr 43165

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

bun-43165 --bun

[claude]

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

Beyond the inline findings, I also checked the new NestingRequirement::Scoped variant against every match on the discriminant (the _ => {} arm in parse_selector at src/css/selectors/parser.rs:672 correctly gives scoped rules no implicit prefix, and the Prefixed check at line 547 is unaffected), and that Printer::in_scope_rule survives with_cleared_context/with_context (both mutate ctx in place rather than cloning the printer) and is restored on the error path of ScopeRule::to_css. @ media/@ supports nested in @ scope propagate both is_in_scope_rule and allow_declarations, so & { } wrapping and :where(:scope) output are consistent there.

Extended reasoning...

Two confirmed findings are already attached inline (declaration ordering inside @ scope and the inconsistent anchor for relative selectors in nested @ scope), so a human look is already signaled. This note only records the adjacent concerns examined and ruled out: the enum-variant audit for NestingRequirement::Scoped, the persistence and restoration of the new Printer::in_scope_rule flag across context helpers and error returns, and flag propagation through conditional at-rules nested inside @ scope. The three candidate issues from the ruled-out list (start-less @ scope to (...) in a style rule, DiscardList rejecting previously-tolerated preludes, and @ scope () empty parens) were not independently re-verified here.

One verified lower-impact observation (a convention, logging or cleanup point) was not posted.

[robobun]

Review follow-ups are in. 6eb7c8d parses a scope-start selector inside another @scope as a scoped selector, so a leading combinator has the same anchor as a scoped style rule. a450bd1 shortens the comments that the comment check flagged. The ordering of declarations after nested rules in an @scope block stays as it is for a nested @media, since both use the same helper.

[claude]

I re-reviewed the follow-up commits and found no bugs; the change to parse an inner <scope-start> with NestingRequirement::Scoped addresses the nested-@ scope anchor mismatch I raised, and the new @ scope (.p) { @ scope (> .a) ... } row pins it. Because this changes emitted CSS for every @ scope user (scoped rules lose their :scope/& prefix, & becomes :where(:scope), invalid <scope-start>/<scope-end> lists now fail the build), a human look at the spec interpretation would still be worthwhile.

What was reviewed:

• is_in_scope_rule propagation in parse_nested: carried through @ media/@ supports inside @ scope, cleared by a style rule, set again by a nested @ scope — matches the tests for each case.
• Printer::in_scope_rule save/restore in ScopeRule::to_css: restored on both the Ok and Err path since the body is a closure whose result is captured before the reset.
• The re-pinned assertion in nested-selector-list-expansion.test.ts: the outer .a, .b chain no longer flows into the scoped rules, only the level nested inside them, which is the intended scoped-rule semantics rather than a weakened check.

Extended reasoning...

Overview

The PR reworks @ scope handling in the CSS parser and printer to follow css-cascade-6 scope nesting and scoped rules. NestedRuleParser gains is_in_scope_rule, a new parse_scope_block path enables bare declarations in @ scope (wrapped in a & {} rule), style rules directly in @ scope parse as relative selector lists with the new NestingRequirement::Scoped, and a <scope-start> inside a style rule gets the implicit & prefix. On the printer side, Printer::in_scope_rule makes a context-less & serialize to :where(:scope) inside @ scope when nesting is compiled away. Both prelude selector lists switch to DiscardList so an invalid selector rejects the rule. Since my earlier review, two commits landed: one parses an inner <scope-start> in another @ scope as Scoped (addressing one of my inline findings, with a new test row), and one trims comments.

Security risks

None specific to this change. The code parses stylesheet text that is already untrusted input to the CSS parser, but the diff adds no new allocation, indexing, or unsafe code; the new paths reuse the existing selector parser entry points and the arena-backed StyleRule construction that the @ media/@ supports nested-declaration path already uses.

Level of scrutiny

Moderate to high. The Rust changes are small and easy to follow, but they encode spec semantics that determine what CSS ships to browsers for every user of @ scope, and the PR intentionally changes existing expected outputs (:scope to :where(:scope), dropped & /:scope prefixes on scoped rules, <scope-start> gaining the parent prefix) plus one breaking change (unforgiving prelude lists). I checked each updated expectation against the stated spec references and the PR's Chrome comparison and they are consistent, but a maintainer familiar with the CSS pipeline should confirm the interpretation and accept the breaking change, which is why I am deferring rather than approving.

Other factors

The bug hunt ended on a dry streak with no findings. Test coverage is substantial: roughly 30 new minify_test/prefix_test rows covering scope nesting inside style rules, relative selectors with each combinator, @ media inside @ scope, declarations before and after nested rules, nested @ scope, and three error cases with an exact message match. The nested-selector-list-expansion.test.ts assertion was changed from two toContain checks to a single exact-substring check on the scoped output, which is stronger, not weaker. My earlier optional note about & {} rules being inserted at index 0 (ahead of rules that precede the declarations in source) was resolved by the author without a code change; the behavior mirrors the pre-existing @ media/@ supports nested-declaration path, so I have not restated it here.

[Jarred-Sumner]

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

@scope: & and implicit selectors compile to :where(:scope), relative selectors and bare declarations parse. 7 real stylesheets

[robobun]

Confirmed on main (7942008): items 1 to 5 of the list are in. The scope-start selector nests, scoped rules take relative selectors and get no prefix, & compiles to :where(:scope), and bare declarations parse. Items 6 (forgiving scope-start and scope-end lists) and 7 (&div) are not in, and this PR stays closed.