diff --git a/css/css-cascade/scope-nesting.html b/css/css-cascade/scope-nesting.html
index d299ba30370516..c0fc7150fae00a 100644
--- a/css/css-cascade/scope-nesting.html
+++ b/css/css-cascade/scope-nesting.html
@@ -339,16 +339,15 @@
   <div>
     <style>
       .a {
-        /* We're supposed to prepend :scope to this declaration. If we do that,
-           then :where() does not matter, since :scope does not gain any
-           specificity from the enclosing @scope rule. However, if an
-           implementation incorrectly prepends & instead, then :where() is
-           needed to avoid the test incorrectly passing due to specificity. */
-        @scope (:where(&) .b) {
+        /* The '& .b' selector is wrapped in :where() to prevent a false
+           positive when the implementation incorrectly wraps
+           the z-index declaration in a rule with &-behavior
+           rather than :where(:scope)-behavior. */
+        @scope (:where(& .b)) {
           z-index: 1; /* Should win due to proximity */
         }
       }
-      .b { z-index: 2; }
+      :where(.b) { z-index: 2; }
     </style>
     <div class=a>
       <div class="b x">
diff --git a/css/css-nesting/nested-declarations-cssom.html b/css/css-nesting/nested-declarations-cssom.html
new file mode 100644
index 00000000000000..42e3930fbeb5df
--- /dev/null
+++ b/css/css-nesting/nested-declarations-cssom.html
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<title>CSS Nesting: CSSNestedDeclarations CSSOM</title>
+<link rel="help" href="https://drafts.csswg.org/css-nesting-1/#nested-declarations-rule">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      .a {
+        & { --x:1; }
+        --x:2;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 2);
+    assert_equals(outer.cssRules[0].cssText, `& { --x: 1; }`);
+    assert_equals(outer.cssRules[1].cssText, `--x: 2;`);
+  }, 'Trailing declarations');
+
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      .a {
+        --a:1;
+        --b:1;
+        & { --c:1; }
+        --d:1;
+        --e:1;
+        & { --f:1; }
+        --g:1;
+        --h:1;
+        --i:1;
+        & { --j:1; }
+        --k:1;
+        --l:1;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 6);
+    assert_equals(outer.cssRules[0].cssText, `& { --c: 1; }`);
+    assert_equals(outer.cssRules[1].cssText, `--d: 1; --e: 1;`);
+    assert_equals(outer.cssRules[2].cssText, `& { --f: 1; }`);
+    assert_equals(outer.cssRules[3].cssText, `--g: 1; --h: 1; --i: 1;`);
+    assert_equals(outer.cssRules[4].cssText, `& { --j: 1; }`);
+    assert_equals(outer.cssRules[5].cssText, `--k: 1; --l: 1;`);
+  }, 'Mixed declarations');
+
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      .a {
+        & { --x:1; }
+        --y:2;
+        --z:3;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 2);
+    let nested_declarations = outer.cssRules[1];
+    assert_true(nested_declarations instanceof CSSNestedDeclarations);
+    assert_equals(nested_declarations.style.length, 2);
+    assert_equals(nested_declarations.style.getPropertyValue('--x'), '');
+    assert_equals(nested_declarations.style.getPropertyValue('--y'), '2');
+    assert_equals(nested_declarations.style.getPropertyValue('--z'), '3');
+  }, 'CSSNestedDeclarations.style');
+
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      .a {
+        @media (width > 100px) {
+          --x:1;
+          --y:1;
+          .b { }
+          --z:1;
+        }
+        --w:1;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 2);
+
+    // @media
+    let media = outer.cssRules[0];
+    assert_equals(media.cssRules.length, 3);
+    assert_true(media.cssRules[0] instanceof CSSNestedDeclarations);
+    assert_equals(media.cssRules[0].cssText, `--x: 1; --y: 1;`);
+    assert_equals(media.cssRules[1].cssText, `& .b { }`);
+    assert_true(media.cssRules[2] instanceof CSSNestedDeclarations);
+    assert_equals(media.cssRules[2].cssText, `--z: 1;`);
+
+    assert_true(outer.cssRules[1] instanceof CSSNestedDeclarations);
+    assert_equals(outer.cssRules[1].cssText, `--w: 1;`);
+  }, 'Nested group rule');
+
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      .a {
+        @scope (.foo) {
+          --x:1;
+          --y:1;
+          .b { }
+          --z:1;
+        }
+        --w:1;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 2);
+
+    // @scope
+    let scope = outer.cssRules[0];
+    assert_equals(scope.cssRules.length, 3);
+    assert_true(scope.cssRules[0] instanceof CSSNestedDeclarations);
+    assert_equals(scope.cssRules[0].cssText, `--x: 1; --y: 1;`);
+    assert_equals(scope.cssRules[1].cssText, `.b { }`); // Implicit :scope here.
+    assert_true(scope.cssRules[2] instanceof CSSNestedDeclarations);
+    assert_equals(scope.cssRules[2].cssText, `--z: 1;`);
+
+    assert_true(outer.cssRules[1] instanceof CSSNestedDeclarations);
+    assert_equals(outer.cssRules[1].cssText, `--w: 1;`);
+  }, 'Nested @scope rule');
+
+  test(() => {
+    let s = new CSSStyleSheet();
+    s.replaceSync(`
+      a {
+        & { --x:1; }
+        width: 100px;
+        height: 200px;
+        color:hover {}
+        --y: 2;
+      }
+    `);
+    assert_equals(s.cssRules.length, 1);
+    let outer = s.cssRules[0];
+    assert_equals(outer.cssRules.length, 4);
+    assert_equals(outer.cssRules[0].cssText, `& { --x: 1; }`);
+    assert_equals(outer.cssRules[1].cssText, `width: 100px; height: 200px;`);
+    assert_equals(outer.cssRules[2].cssText, `& color:hover { }`);
+    assert_equals(outer.cssRules[3].cssText, `--y: 2;`);
+  }, 'Inner rule starting with an ident');
+</script>
diff --git a/css/css-nesting/nested-declarations-matching.html b/css/css-nesting/nested-declarations-matching.html
new file mode 100644
index 00000000000000..0dc272e1a7ba5b
--- /dev/null
+++ b/css/css-nesting/nested-declarations-matching.html
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<title>CSS Nesting: CSSNestedDeclarations matching</title>
+<link rel="help" href="https://drafts.csswg.org/css-nesting-1/#nested-declarations-rule">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<style>
+  .trailing {
+    --x: FAIL;
+    & { --x: FAIL; }
+    --x: PASS;
+  }
+</style>
+<div class=trailing></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.trailing');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Trailing declarations apply after any preceding rules');
+</script>
+
+
+<style>
+  .trailing_no_leading {
+    & { --x: FAIL; }
+    --x: PASS;
+  }
+</style>
+<div class=trailing_no_leading></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.trailing_no_leading');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Trailing declarations apply after any preceding rules (no leading)');
+</script>
+
+
+<style>
+  .trailing_multiple {
+    --x: FAIL;
+    --y: FAIL;
+    --z: FAIL;
+    --w: FAIL;
+    & { --x: FAIL; }
+    --x: PASS;
+    --y: PASS;
+    & { --z: FAIL; }
+    --z: PASS;
+    --w: PASS;
+  }
+</style>
+<div class=trailing_multiple></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.trailing_multiple');
+    let s = getComputedStyle(e);
+    assert_equals(s.getPropertyValue('--x'), 'PASS');
+    assert_equals(s.getPropertyValue('--y'), 'PASS');
+    assert_equals(s.getPropertyValue('--z'), 'PASS');
+    assert_equals(s.getPropertyValue('--w'), 'PASS');
+  }, 'Trailing declarations apply after any preceding rules (multiple)');
+</script>
+
+
+<style>
+  .trailing_specificity {
+    --x: FAIL;
+    :is(&, div.nomatch2) { --x: PASS; } /* Specificity: (0, 1, 1) */
+    --x: FAIL; /* Specificity: (0, 1, 0) */
+  }
+</style>
+<div class=trailing_specificity></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.trailing_specificity');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Nested declarations rule has same specificity as outer selector');
+</script>
+
+
+<style>
+  #nomatch, .specificity_top_level {
+    --x: FAIL;
+    :is(&, div.nomatch2) { --x: PASS; } /* Specificity: (0, 1, 1) */
+    --x: FAIL; /* Specificity: (0, 1, 0). In particular, this does not have
+               specificity like :is(#nomatch, .specificity_top_level). */
+  }
+</style>
+<div class=specificity_top_level></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.specificity_top_level');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Nested declarations rule has top-level specificity behavior');
+</script>
+
+
+<style>
+  #nomatch, .specificity_top_level_max, div.specificity_top_level_max {
+    --x: FAIL;
+    :is(:where(&), div.nomatch2) { --x: FAIL; } /* Specificity: (0, 1, 1) */
+    --x: PASS; /* Specificity: (0, 1, 1) (for div.specificity_top_level_max) */
+  }
+</style>
+<div class=specificity_top_level_max></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.specificity_top_level_max');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Nested declarations rule has top-level specificity behavior (max matching)');
+</script>
+
+<style>
+  .nested_pseudo::after {
+    --x: FAIL;
+    @media (width > 0px) {
+      --x: PASS;
+    }
+  }
+</style>
+<div class=nested_pseudo></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.nested_pseudo');
+    assert_equals(getComputedStyle(e, '::after').getPropertyValue('--x'), 'PASS');
+  }, 'Bare declartaion in nested grouping rule can match pseudo-element');
+</script>
+
+<style>
+  #nomatch, .nested_group_rule {
+    --x: FAIL;
+    @media (width > 0px) {
+      --x: FAIL; /* Specificity: (0, 1, 0) */
+    }
+    --x: PASS;
+  }
+</style>
+<div class=nested_group_rule></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.nested_group_rule');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Nested group rules have top-level specificity behavior');
+</script>
+
+
+<style>
+  .nested_scope_rule {
+    div:where(&) { /* Specificity: (0, 0, 1) */
+    --x: PASS;
+    }
+    @scope (&) {
+      --x: FAIL; /* Specificity: (0, 0, 0) */
+    }
+  }
+</style>
+<div class=nested_scope_rule></div>
+<script>
+  test(() => {
+    let e = document.querySelector('.nested_scope_rule');
+    assert_equals(getComputedStyle(e).getPropertyValue('--x'), 'PASS');
+  }, 'Nested @scope rules behave like :where(:scope)');
+</script>
diff --git a/css/css-nesting/nesting-basic.html b/css/css-nesting/nesting-basic.html
index 19ff48e4a29588..9edff4ea1af6a2 100644
--- a/css/css-nesting/nesting-basic.html
+++ b/css/css-nesting/nesting-basic.html
@@ -68,9 +68,9 @@
 
   .test-10 {
     & {
-      background-color: green;
+      background-color: red;
     }
-    background-color: red;
+    background-color: green;
   }
 
   .test-11 {
diff --git a/css/css-nesting/serialize-group-rules-with-decls.html b/css/css-nesting/serialize-group-rules-with-decls.html
index 7e9aaafbeb894c..e15210c2dd2dca 100644
--- a/css/css-nesting/serialize-group-rules-with-decls.html
+++ b/css/css-nesting/serialize-group-rules-with-decls.html
@@ -35,12 +35,12 @@
 
   assert_becomes(
     "div { @media screen { color: red; background-color: green; } }",
-    "div {\n  @media screen {\n  & { color: red; background-color: green; }\n}\n}",
+    "div {\n  @media screen {\n  color: red; background-color: green;\n}\n}",
     "Mixed declarations/rules are on two lines."
   );
   assert_becomes(
     "div {\n  @supports selector(&) { color: red; background-color: green; } &:hover { color: navy; } }",
-    "div {\n  @supports selector(&) {\n  & { color: red; background-color: green; }\n}\n  &:hover { color: navy; }\n}",
+    "div {\n  @supports selector(&) {\n  color: red; background-color: green;\n}\n  &:hover { color: navy; }\n}",
     "Implicit rule is serialized",
   );
 
@@ -62,12 +62,12 @@
   );
   assert_becomes(
     "div { @media screen { color: red; & { color: red; }",
-    "div {\n  @media screen {\n  & { color: red; }\n  & { color: red; }\n}\n}",
+    "div {\n  @media screen {\n  color: red;\n  & { color: red; }\n}\n}",
     "Implicit like rule after decls"
   );
   assert_becomes(
     "div { @media screen { color: red; & { color: blue; }",
-    "div {\n  @media screen {\n  & { color: red; }\n  & { color: blue; }\n}\n}",
+    "div {\n  @media screen {\n  color: red;\n  & { color: blue; }\n}\n}",
     "Implicit like rule after decls, missing closing braces"
   );
   assert_becomes(
diff --git a/css/css-syntax/custom-property-rule-ambiguity.html b/css/css-syntax/custom-property-rule-ambiguity.html
index 04f908acde2e72..a8ac1de2c556ea 100644
--- a/css/css-syntax/custom-property-rule-ambiguity.html
+++ b/css/css-syntax/custom-property-rule-ambiguity.html
@@ -46,11 +46,12 @@
     assert_equals(rules.length, 1);
     assert_equals(rules[0].selectorText, 'div');
     let div = rules[0];
-    let x = div.style.getPropertyValue('--x');
-    assert_equals(x.trim(), 'hover { }\n    .b { }');
     let childRules = div.cssRules;
-    assert_equals(childRules.length, 1);
+    assert_equals(childRules.length, 2);
     assert_equals(childRules[0].selectorText, '& .a');
+    assert_true(childRules[1] instanceof CSSNestedDeclarations)
+    let x = childRules[1].style.getPropertyValue('--x');
+    assert_equals(x.trim(), 'hover { }\n    .b { }');
   }, 'Nested rule that looks like a custom property declaration');
 </script>
 
