Oleg
Chursin
WorkNotesPhotography
Feature-detecting CSS when engines half-ship

What @supports, at-rule() and named-feature() actually test, why two 2026 changes made feature checks and Baseline mislead, and how to gate CSS so the answer stays correct.

Contents · 10 sections

In July 2026, Firefox 153 started answering "yes" to a question it had always answered "no". The release notes say that ::-webkit-scrollbar "is now recognized, so the @supports selector(::-webkit-scrollbar) check returns true", and add, in the same paragraph, that scrollbar styling through it "is not truly implemented". Six weeks later, Firefox 155 took the answer back for most of the web, because sites that trusted it had broken scrollbars. Two weeks after that, Firefox 156 said "no" everywhere, while still acting on some of those rules on a list of sites.

Anchor positioning had the opposite problem. Firefox turned it on by default in version 147 in January 2026, the last of the three engines to do so. And yet webstatus.dev still lists it as "limited" today, with exactly one browser, Safari 27, shown as implementing the whole feature. Nothing regressed. The CSS Working Group renamed two keywords, and one engine shipped the new names first.

Both stories come from the same gap. @supports answers a narrow, precisely defined question: will this engine's parser accept this piece of syntax? People read the answer as a broader one: does this feature work here? Baseline answers a third question, aggregated over hundreds of compat keys. Below are the exact rules behind each answer, the functions CSS Conditional Level 5 adds to close part of the gap (at-rule(), named-feature() and @supports-condition), both case studies in detail, and a gating recipe that keeps working when an engine half-ships, renames or fibs.

This is part 2 of "Reading CSS". Part 1, on why CSS has no version, covers spec maturity, and the platform track's piece on Baseline covers how the status is computed, so I won't repeat either. Every status fact below was checked on 18 October 2026.

@supports asks the parser, not the renderer

The definition is narrower than most people assume. CSS Conditional Rules Level 3 says a processor supports a declaration "if it accepts that declaration (rather than discarding it as a parse error) within a style rule". The obligation attached to it is the important part: "If a processor does not implement, with a usable level of support, both the property and the value given, then it must not accept the declaration or claim support for it."

So the contract is two-sided. The engine promises not to accept syntax it can't back up, and in return you get a parse-level signal you can branch on. The spec is explicit that this is the same mechanism that makes the old "write the fallback declaration first" pattern work: a compound value is supported only if every part of it is implemented, "either inside a style rule or in the declaration condition of an @supports rule." The next Note in this series covers what happens to that fallback pattern once custom properties are involved. Here, what matters is the scope of the promise: it covers parsing and a "usable level of support". It says nothing about edge cases, bugs, or what a feature does in combination with others.

Two details in the same section are easy to miss and matter later. First, user preferences don't change the answer. A high-contrast mode that overrides colors doesn't make color unsupported. Second, the opposite holds for developer flags: "a developer-facing preference whose purpose is to enable or disable support for an experimental CSS feature does affect this definition of support." That sentence is what lets an about:config pref, like the one Firefox 151 added for ::-webkit-scrollbar, legitimately change an @supports answer.

Unknown conditions are false, and not makes them true

The @supports grammar is deliberately loose. Alongside declarations and functions it accepts <general-enclosed>, which matches any balanced function or parenthesized block the engine doesn't understand. The spec gives it a fixed result: "The result is false." It exists, the spec says, "so that new syntax additions do not invalidate too much of a <supports-condition> in older user agents."

That's a good design for positive tests. An engine that has never heard of at-rule() sees at-rule(@scope) as an unknown function, evaluates it to false, and skips the block. It's a trap for negative tests, because not negates whatever the inner term produced. In that same engine, @supports not at-rule(@scope) is true, whether or not the engine supports @scope. The block you wrote for "browsers without @scope" runs in a browser that has it, because the browser can't parse the question.

This isn't hypothetical in October 2026. Safari has supported @scope since 26.4, and it doesn't yet support at-rule() in a stable release (more on that below). I confirmed the general mechanism in the one engine I could run, described in the measurement section: @supports not made-up-function(x) matched.

/* Broken: in an engine without at-rule(), this block runs
   even when @scope works, because not(unknown) is true. */
@supports not at-rule(@scope) {
  .card .title { color: var(--card-title); }
}

The safe pattern is to put the unscoped style first, unconditionally, and override it inside a positive test. Then an engine that can't parse the test keeps the fallback, and an engine that can gets the enhancement.

CSS.supports() mostly mirrors the rule, with one documented exception

The JavaScript side is defined in the same spec. The one-argument form, CSS.supports(conditionText), evaluates its argument as a <supports-condition>, and if that doesn't return true, tries again with the text wrapped in parentheses. So CSS.supports('display: grid') works, and so does anything you can write after @supports, including the Level 5 functions.

The two-argument form is different. CSS.supports(property, value) returns true if the property is one the engine supports, or a custom property name, "and value successfully parses according to that property's grammar." The spec's note spells out the consequence: "!important flags are not part of property grammars, and will cause value to parse as invalid." The @supports rule goes the other way. Conditional Level 5 says its <declaration> matches anything "consume a declaration" would parse, and "Notably, this includes a trailing !important, which is valid but ignored for the purpose of @supports."

// Per the specs, these two disagree.
CSS.supports('color: red !important'); // true: parsed as a condition
CSS.supports('color', 'red !important'); // false: !important isn't grammar

Nobody writes !important in a feature test on purpose. The point is that "the CSS rule and the JavaScript API always agree" is a claim about one form of the API, and you should use that form when the two need to agree.

Level 5 adds functions for things a declaration can't express

A declaration test can only ask about properties and values. Over the years the CSS Working Group has added functions for the other kinds of syntax. CSS Conditional Rules Level 5, an Editor's Draft dated 8 October 2026, now defines <supports-feature> as one of seven forms: selector(), font-tech(), font-format(), at-rule(), named-feature(), env(), or a declaration (which may be replaced by the name of a custom support condition).

They're at very different stages. In web-features 3.43.0 (the npm latest tag on 18 October 2026), the @supports feature's compat keys show selector(), font-tech() and font-format() as Baseline widely available. Their newly available dates were 26 April 2021 for selector() and 18 September 2023 for the two font functions. at-rule() and named-feature() are separate features, both limited. @supports-condition has no web-features entry at all, and I found no BCD file and no Chrome Platform Status entry for it.

selector() is defined to see through forgiving parsing, and -webkit- quirks

selector() is the oldest of the functions and the one at the center of the Firefox story, so its definition is worth reading exactly. Conditional Level 4 says a processor supports a selector if it accepts "all aspects of that selector, recursively, (rather than considering any of its syntax to be unknown or invalid) and that selector doesn't contain unknown -webkit- pseudo-elements." A note adds that some functional selectors parse forgivingly, so an unknown argument doesn't invalidate the selector, but "These are nonetheless unsupported."

The -webkit- clause exists because of a compatibility rule in Selectors Level 4's Appendix B. Every engine must treat any non-functional pseudo-element whose name starts with -webkit- as "valid at parse time", and if it isn't otherwise recognized, as matching nothing. Those are "unknown -webkit- pseudo-elements". The appendix explains the history: WebKit-derived engines have long accepted any ::-webkit- selector at parse time, enough sites came to depend on that, and other engines were seeing breakage.

Put the two rules together and selector(::-webkit-scrollbar) has a very specific meaning. Parsing always succeeds. The function returns true only if the engine knows the pseudo-element. It's the one bit that separates "this engine treats ::-webkit-scrollbar as a real thing" from "this engine is required to tolerate it". Keep that in mind for the case study.

at-rule() tests the keyword and nothing else

The Level 5 definition is one sentence: a processor supports an at-rule "if it would accept an at-rule beginning with the specified at-keyword within any context." A note adds that @charset is not considered supported, because it isn't a valid at-rule.

That's deliberately minimal, and the issue history shows the group chose it. The original 2022 resolution in issue #2463 was to add "an at-rule function with syntax at-rule(@keyword) or at-rule(@keyword; descriptor: value)". In August 2025, issue #6966 recorded "RESOLVED: Cut down the at-rule test to just at-rule(@foo) (no descriptor testing)". The draft's Changes section records the function as added since the Working Draft of 5 November 2024, citing both issues among others. The same meeting settled the edge cases in issue #11116: "at-rule(@charset) is invalid, but at-rule(@import) is allowed."

So at-rule(@property) tells you the engine knows @property. It doesn't tell you which syntax strings it accepts. at-rule(@container) tells you nothing about style queries or scroll-state queries, which share the at-keyword. at-rule() is useful for at-rules that arrived as a unit, like @scope, @starting-style or @position-try. For anything layered on an existing at-rule, it's the wrong tool.

Shipping, as of 18 October 2026:

The result is limited on webstatus.dev: Chrome 148, Edge 148 and Firefox 157, with no Safari. One source disagrees. The Chrome Platform Status entry records Safari's signal as "Shipped/Shipping" and links the WebKit bug. That field is a hand-maintained signal on Chrome's tracker, and the bug shows a commit to WebKit's main branch, not a release. I trust BCD and the absence from the Safari 27 notes over it.

Since the function can arrive inside @import, the conditional-import grammar is worth knowing. Cascade Level 5 defines supports( [ <supports-condition> | <declaration> ] ) after the URL and optional layer:

app.css
/* Load the scoped component styles only where @scope parses.
   Engines without at-rule() treat it as false and skip it. */
@import url("components-scoped.css") layer(components)
  supports(at-rule(@scope));

The same false-negative logic applies: in Safari 27 that stylesheet won't load, even though @scope works there. If that's not acceptable, the fallback must be a full, correct stylesheet of its own, which is the theme of the recipe later on.

@supports-condition names a test, and no engine ships it

§8 of the Level 5 draft adds @supports-condition, which defines a named supports query. Anything inside its block "is evaluated to test whether the user agent supports the features used", and the name can then be used in @supports or @when. If two rules share a name, "the last one in document order wins". The part that matters most: these rules "are allowed before @import and @namespace rules", which makes the spec's own nesting example possible:

@supports-condition --nesting {
  & { }
}
@import url("nested-styles.css") supports(--nesting);

If it ships, that's a way to gate a whole stylesheet on whether nesting parses, or on whether an arbitrary at-rule prelude parses, without JavaScript. The spec's other example detects scroll-state container queries by putting an @container scroll-state(stuck: top) rule inside the block.

It isn't ready. The draft carries an inline issue: "The name of the at-rule is under discussion," with @supports-query, @supports-test and @custom-supports as alternatives. The tracking issue #12622 is open, and its latest resolution, from 25 March 2026, is "Use @supports (--foo) for custom supports conditions." In the Chromium build I tested, the rule was dropped and @supports (--name) was false. Treat it as a design to watch, not a tool.

named-feature() is a list the Working Group keeps short

Some changes have no syntax to test. A property starts working on a new display type, or an existing feature changes behavior. No declaration parses differently, so @supports can't see it. The Working Group's answer came in issue #3559, open since January 2019: a resolution on 10 January 2024 to "adopt keyword based feature queries, with names to be bikeshedded later, with the expectation that we will use them rarely and test and message their addition carefully." On 17 July 2024, issue #9875 recorded "RESOLVED: use named-feature() as the function name".

The explainer, written by L. David Baron in January 2026, gives the reasoning. The alternative, testing combinations like (align-content: stretch) with (display: block), would mean defining support for "millions of combinations". Instead, the group names the few cases with real demand, "probably a low single digit number per year".

The current list has two entries:

  • anchor-position-follows-transforms: anchoring to a transformed element "automatically takes into account the anchor's transforms". An earlier version of anchor positioning ignored them.
  • single-axis-scroll-container: one axis scrolls and the other is clip. Previously, clip alongside a scrollable value computed to hidden.

"If the feature is not listed the processor does not support the named feature." So a misspelled name is silently false. That's not a theoretical risk. On 18 October 2026, the example on MDN's @supports page reads named-feature(anchor-position-follows-transform), without the final "s", while the keyword listed below it is spelled correctly. Paste the example and you get false in every engine. Issue #9875 also resolved a first keyword, align-content-on-display-block, which appears in the explainer's example but isn't in today's list.

Shipping, as of 18 October 2026:

  • Chrome. Chrome Platform Status lists a developer trial in 146 and shipping in 150 (30 June 2026), "initially with a single supported feature", anchor-position-follows-transforms. BCD records single-axis-scroll-container from Chrome 154.
  • Firefox. Firefox 156 lists named-feature() as experimental, behind layout.css.anchor-positioning.follows-transforms.enabled. A comment on Mozilla bug 2042977 describes the companion patch as making the function "aware of the anchor transform pref", so the detection and the behavior it reports share one switch. Mozilla's standards position is positive.
  • Safari. Not supported. WebKit's standards-position issue #600 has one comment, from 31 July 2026: "No position yet, but I've started prototyping". The prototype bug, WebKit bug 320705, shows a commit to WebKit's main branch on 18 August 2026 and is resolved as fixed. No Safari release includes it, and BCD lists Safari as unsupported.

webstatus.dev has it as limited, Chromium only.

Firefox's choice of pref is the right design, and it points at the rule that makes named-feature() trustworthy at all. A named feature is only useful if the answer changes in the same release as the behavior. When the detection lags the behavior, you get false negatives. The anchor case study shows how long that lag can be.

Firefox's ::-webkit-scrollbar answered yes, then no

Here's the sequence, with dates from BCD's Firefox release data. Fig. 1 plays it back.

Firefox 151, 19 May 2026. The release notes list an experimental pref, layout.css.fake-webkit-scrollbar.enabled, added "to fix an issue where scrollable content was unreachable": if a site set a scrollbar to display: none or width: 0, the scrollbars of nested scrollable areas could stack on top of each other. The page lists it among experimental features you enable in about:config, so on default settings ::-webkit-scrollbar stayed an unknown -webkit- pseudo-element. On my reading of Conditional Level 4, that keeps selector() false.

Firefox 153, 21 July 2026. The notes say the pseudo-element "is now recognized, so the @supports selector(::-webkit-scrollbar) check returns true", while scrollbar styling through it "is not truly implemented".

Firefox 155, 1 September 2026. Partial support "is now limited to a small list of sites rather than to the whole web", kept in layout.css.fake-webkit-scrollbar.enabled-domains. On any other domain, the check returns false. The notes give the reason: the 153 change "caused broken scrollbars on some sites", which "relied on styling with other ::-webkit-scrollbar-* pseudo-elements, which Firefox doesn't support." They also say what Firefox acts on: display: none, which hides the scrollbar, and a non-zero width or height, which turns off overlay scrollbars for that scroll container.

Firefox 156, 15 September 2026. The pseudo-element is now reported as unsupported "on every site", including the allow-listed ones, so selector(::-webkit-scrollbar) is false and not (selector(::-webkit-scrollbar)) is true. Firefox "still acts on ::-webkit-scrollbar rules on those sites, but it no longer reports the pseudo-element as supported." The notes name the failure mode directly: "Sites use this check as a signal that the whole ::-webkit-scrollbar-* family is supported", and sites "that guard their standard scrollbar styles behind @supports not (selector(::-webkit-scrollbar)) now get those styles applied in Firefox."

One more fact makes this worse than a two-month blip. BCD lists Firefox 153 with the status "esr". Organizations on the Extended Support Release track sit on a branch for a long time, and I couldn't find whether the 155 or 156 change was carried back to it. That's in the last section.

The engine kept changing its answer, and the sites' inference broke

Firefox 153 wasn't breaking a rule. Conditional Level 4 makes selector() true when the engine recognizes the pseudo-element, and Firefox did recognize it, with a narrow implementation aimed at a real bug. Firefox 156 goes the other way: it reports "unsupported" while still acting on the rules on some sites. On my reading of Level 4 that departs from the letter of the definition, and the release notes give the compatibility reason for doing it anyway.

What broke was the inference. A selector test answers "does this parser accept this selector as known?" The sites read it as "is this whole family of pseudo-elements implemented?", and in some cases as "is this a WebKit or Blink browser?" The second question is a browser sniff dressed as a feature query, and it fails the moment any engine changes its answer for its own reasons.

scrollbars.css
/* Broken: the @supports test is used as "is this Firefox?" */
@supports not selector(::-webkit-scrollbar) {
  .panel {
    scrollbar-width: thin;
    scrollbar-color: gray transparent;
  }
}

The fix is to stop asking which browser this is. The standard properties don't need a guard: an engine that doesn't know them drops the declarations. scrollbar-width has been Baseline newly available since 11 December 2024 and scrollbar-color since 12 December 2025.

scrollbars.css
/* Fixed: standard properties, unconditionally. */
.panel {
  scrollbar-width: thin;
  scrollbar-color: gray transparent;
}

There's a reason sites reached for the guard, and it's worth knowing before you delete it. MDN's scrollbar-color page notes that browsers ignore the whole ::-webkit-scrollbar family on any element whose computed scrollbar-color isn't auto, and since the property inherits, that includes descendants. scrollbar-width has the same rule. So the unconditional version above also switches off any custom ::-webkit-scrollbar-thumb styling on .panel in Chromium and WebKit. That's the real decision: standard scrollbars everywhere, or WebKit-style custom scrollbars where they exist. If you pick the second, scope the ::-webkit-scrollbar-* rules to elements that leave scrollbar-color and scrollbar-width at auto, and make sure each rule is correct in an engine that ignores it. Neither choice needs a feature query that pretends to identify a browser.

Anchor positioning shipped everywhere and is still "limited"

The second case is subtler, because nothing about it is wrong. It's what happens when a feature is defined by hundreds of compat keys and the spec changes under one of them.

In web-features 3.43.0, anchor-positioning has baseline: false, and its headline support lists only safari: 27 and safari_ios: 27. That headline isn't saying Chrome and Firefox lack anchor positioning. It's the set of browsers that support every one of the feature's 325 compat keys. web-features' guidelines say most features "compute a status from @mdn/browser-compat-data (BCD) compat keys given by the compat_features array", and the anchor-positioning feature lists all 325 in a flat array, with no override. The Baseline definition requires that "each current stable release in the core browser set" supports the feature. One key that Chrome lacks is enough.

Here's how those 325 keys break down by the date each one became Baseline newly available, read from by_compat_key in the same data file:

Baseline low date Keys What they are Last engine to ship
13 January 2026 276 anchor-name, position-area, position-try-fallbacks and most of the feature Firefox 147
21 January 2026 4 flip-x and flip-y in position-try and position-try-fallbacks Edge 144
24 February 2026 39 most single position-area keywords, the self-x/self-y try options, position-try-order Firefox 148
14 September 2026 4 position-anchor and its auto, none and normal values Safari 27
not Baseline 2 position-visibility: anchor-valid and anchor-visible Safari 27 only

Fig. 2 draws the same numbers.

Two things stand out. The position-anchor row moved to 14 September 2026 even though the property shipped long before: web-features now records Chrome 151, Firefox 151 and Safari 27 for it, which lines up with the default changing to normal (Firefox 151 added the value, and WebKit's Safari 27 post describes the new default). A per-key date tells you when the current definition of a key became interoperable, not when you could first type the property name. And the whole feature's status hangs on the last row.

A rename in the spec, shipped by one engine

Those two keys come from issue #10201. On 2 April 2026 the minutes record "RESOLVED: Only care about default anchor; rename to anchor-valid." On 6 May 2026: "RESOLVED: rename anchors-visible to anchor-visible". The issue was closed on 29 May 2026. The Editor's Draft, dated 6 September 2026, has the singular keywords and says: "User agents may recognize anchors-valid and anchors-visible as legacy value aliases of anchor-valid and anchor-visible (but are not required to)."

The rename isn't cosmetic for anchor-valid. WebKit's post explains that the old keyword hid an element "if any of its required anchor references couldn't be resolved", that it "wasn't clear what constituted 'required anchor references'", and that the Working Group "changed the behavior to only look at the default anchor box." Safari 27, released 14 September 2026 per BCD's Safari data, "aligns with the new behavior, and temporarily supports the old keywords for compatibility."

The engines on 18 October 2026, per BCD's position-visibility data:

Keyword Chrome Firefox Safari
anchors-visible (old) 125 147 26.2
anchors-valid (old) preview 147 26.2
anchor-visible (new) preview no 27
anchor-valid (new) preview no 27

Two oddities hide in that table. Chrome never shipped the plural anchors-valid in a stable release, so it has been missing a position-visibility keyword the whole time. And web-features handles the rename by moving the plurals into a separate feature, anchor-positioning-position-visibility-plurals, marked discouraged with the reason that the values "were renamed to the singular anchor-valid and anchor-visible values, since they refer to one anchor at a time." So the old names no longer count against anchor positioning. The new names do, and only Safari has them.

Chrome's fix is on the way. The Chrome Platform Status entry, created 23 September 2026, is titled "Ship anchor-visible and anchor-valid, and deprecate the plural versions", targets milestone 157, and states the motivation plainly: "to maintain baseline status for anchor positioning, Chrome needs to ship the new names." Chromium Dash schedules Chrome 157 stable for 3 November 2026. But that alone won't change the Baseline status. By the definition, Firefox has to ship both singular keywords too, and BCD records no Firefox support for them today.

Detecting a renamed keyword without gating the feature on it

The tempting mistake is to gate the whole feature on its newest piece. If you wrap your tooltip layout in @supports (position-visibility: anchor-visible), today you've turned off anchor positioning in Chrome and Firefox, two engines that implement the other 323 keys.

tooltip.css
/* Broken: gates all of anchor positioning on the newest keyword,
   which only Safari 27 parses on 18 October 2026. */
@supports (position-visibility: anchor-visible) {
  .trigger { anchor-name: --trigger; }
  .tooltip {
    position: absolute;
    position-anchor: --trigger;
    position-area: top;
  }
}

Gate on the keys the layout depends on, and let the renamed keyword fall back declaration by declaration. This is the classic duplicate-declaration fallback, and it works here because there's no var() in the value: an engine that doesn't parse the second declaration drops it at parse time and keeps the first.

tooltip.css
.tooltip {
  /* Unenhanced path: an ordinary block after the trigger. */
  margin-block-start: 0.5rem;
}

@supports (anchor-name: --a) and (position-area: top) {
  .trigger { anchor-name: --trigger; }
  .tooltip {
    position: absolute;
    position-anchor: --trigger;
    position-area: top;
    position-try-fallbacks: flip-block;
    margin: 0;
    /* Old name first; the new name wins wherever it parses. */
    position-visibility: anchors-visible;
    position-visibility: anchor-visible;
  }
}

I ran this in the Chromium build described below. The @supports block applied, and the computed position-visibility was anchors-visible, which is the fallback doing its job. For anchors-valid and anchor-valid the same pattern works in Firefox and Safari, but not in Chrome stable, which parses neither yet. Remember that the two valid keywords also differ in meaning, so the fallback isn't a pure alias.

Behavior without syntax: transform-following anchors

The other change in this area has no syntax at all. The current Anchor Positioning draft says the anchor box's position and size "includes zoom and position-based adjustments ... as well as transforms". An earlier version ignored transforms.1 Your stylesheet is identical either way; only the rendering differs. That's what named-feature(anchor-position-follows-transforms) exists for.

The problem is timing. Here's what the data says about each engine, on 18 October 2026:

  • Chrome follows anchor transforms since 144 (13 January 2026), per web-features' anchor-positioning-transforms feature. named-feature() arrived in 150 (30 June 2026). For five and a half months, the detection said "no" in a browser that did it.
  • Safari 27 follows anchor transforms, per WebKit's post ("elements positioned relative to that anchor follow its transformed position"), and doesn't support named-feature(). The detection says "no" today.
  • Firefox has neither on by default. Both sit behind the same pref, so when it flips, they flip together.

Fig. 3 lays the three engines side by side.

So treat a false from named-feature() as "unknown", never as "no". Use it only to opt into something that's harmless to skip:

/* Only where the engine says anchors track transforms:
   let the trigger animate. Elsewhere, the tooltip and its
   trigger stay still, which is correct everywhere. */
@supports named-feature(anchor-position-follows-transforms) {
  .trigger:hover { scale: 1.05; }
}

The draft also notes that transform-based updates to an anchor's position "may be delayed by a few frames" because transforms often run on another thread, and that "Authors can avoid this delay by using absolute or relative positioning instead where practical." That's a design-level fallback that needs no detection at all.

A gating recipe in three layers

Everything above reduces to three layers, each answering a different question. Use them in this order.

Layer 1: syntax gates, written positively

Use declaration tests, selector() and at-rule() to ask whether the parser accepts the exact syntax you're about to use. Three rules keep them honest:

  1. Test what you use. Gate on position-area: top if that's the value you write, not on anchor-name alone, and never on a subfeature you don't use.
  2. Write the test positively. Put the fallback outside the block and the enhancement inside. Avoid not around any function an engine might not know.
  3. Pair new functions with an old-style test. or lets an engine that doesn't understand at-rule() still pass on a declaration it does understand. Because unknown terms evaluate to false rather than invalidating the rule, the or still works in engines that have never seen at-rule().
/* True in engines with at-rule() and @position-try,
   and in engines without at-rule() that parse the property. */
@supports at-rule(@position-try) or
  (position-try-fallbacks: flip-block) {
  .menu { position-try-fallbacks: --below, flip-block; }
}

In the Chromium build I tested, this rule matched, and so did a copy with at-rule replaced by a made-up function name, which is how an engine without at-rule() sees it.

Layer 2: named features, only for listed behaviors

Use named-feature() only for the two behaviors on the list, only to opt into an enhancement, and with the name copied from the spec rather than from an example. A false result means the engine either lacks the behavior or lacks the function, and you can't tell which.

Layer 3: data gates, per compat key, at build time

The runtime gates tell you what one user's browser parses. Your support policy needs to know what your audience's browsers do, and that's a data question. Answer it per compat key, not per feature. A feature-level "limited" can hide 323 interoperable keys, and a feature-level "newly available" can hide one you depend on that isn't.

web-features publishes per-key status in status.by_compat_key. This script reads data.json and reports the keys a stylesheet uses. It's plain Node with no dependencies, and I ran it with Node 24 against web-features 3.43.0.

check-keys.mjs
// Usage: node check-keys.mjs path/to/data.json
import { readFile } from 'node:fs/promises';

// The compat keys this stylesheet actually depends on.
const used = [
  'css.properties.anchor-name',
  'css.properties.position-area',
  'css.properties.position-try-fallbacks',
  'css.properties.position-visibility.anchor-visible',
  'css.properties.position-visibility.anchors-visible'
];

const data = JSON.parse(await readFile(process.argv[2], 'utf8'));

// Index every feature's per-key status by compat key.
const byKey = new Map();
for (const [id, feature] of Object.entries(data.features)) {
  const keys = feature.status?.by_compat_key ?? {};
  for (const [key, status] of Object.entries(keys)) {
    byKey.set(key, { id, ...status });
  }
}

for (const key of used) {
  const s = byKey.get(key);
  if (!s) {
    console.log(`${key}: not in web-features`);
    continue;
  }
  const label = s.baseline
    ? `${s.baseline} since ${s.baseline_low_date}`
    : 'limited';
  console.log(`${key} (${s.id}): ${label}`);
}

Against 3.43.0 it prints the three layout keys as Baseline low since 13 January 2026, anchor-visible as limited under anchor-positioning, and anchors-visible as limited under the plurals feature. That's the policy decision in five lines: the layout ships, the visibility keyword is an enhancement with a fallback. Pin the web-features version in your lockfile and diff the output when you upgrade, so a change in status shows up in code review rather than in production.

Where no gate can see, make the fallback correct

Some behavior can't be detected by any layer: a bug, a partial implementation an engine still reports as supported, or a renamed keyword in an engine that hasn't shipped the new name. For those, the only defense is to make the un-enhanced path correct on its own: content readable, controls reachable, nothing positioned on top of something else. The next Note in this series covers when browsers drop CSS at parse time and why some fallbacks quietly stop working.

What I measured, and in which engine

The right evidence here is a cross-engine matrix: the same conditions, run through @supports rules and CSS.supports() in Chrome, Firefox and Safari stable. I could only run one engine: the Chromium build embedded in the Claude desktop app on macOS, which reports itself as Chrome/152.0.7977.149. That is not Chrome stable (155 on 18 October 2026, per BCD), and it says nothing about Firefox or Safari. I'm reporting it because it confirms several spec-level claims in one real engine, and because the method is easy to repeat.

The method: a static page that, for each condition, inserts a <style> containing @supports <condition> { #tN { --hit: yes; } }, then records three things: whether the browser kept the rule in cssRules, whether --hit computed to yes on the target element, and what CSS.supports(condition) returned.

const cond = 'at-rule(@scope)';
const el = document.body.appendChild(document.createElement('div'));
el.id = 't0';
const style = document.head.appendChild(document.createElement('style'));
style.textContent = `@supports ${cond} { #t0 { --hit: yes; } }`;
console.log({
  kept: style.sheet.cssRules.length > 0,
  rule: getComputedStyle(el).getPropertyValue('--hit').trim() === 'yes',
  api: CSS.supports(cond)
});

Results from that build, run on 18 October 2026 (rule and API columns agreed on every row, so they're merged):

Condition Result
selector(::-webkit-scrollbar) true
selector(::-webkit-scrollbar-thumb) true
selector(::-webkit-made-up-thing) false
at-rule(@scope), at-rule(@starting-style), at-rule(@position-try) true
at-rule(@made-up-rule) false
at-rule(@charset) rule dropped at parse time; API false
named-feature(anchor-position-follows-transforms) true
named-feature(anchor-position-follows-transform) (MDN's spelling) false
named-feature(single-axis-scroll-container) false
(position-visibility: anchors-visible) true
(position-visibility: anchors-valid) false
(position-visibility: anchor-visible), (position-visibility: anchor-valid) false
(color: red !important) true
made-up-function(x) false
not made-up-function(x) true

And CSS.supports('color', 'red !important'), the two-argument form, returned false.

What this does and doesn't show:

  • The two JavaScript forms diverge exactly as specified. The one-argument form agreed with the rule on all of these conditions. The two-argument form rejected !important.
  • The not trap is real in this engine. An unknown function evaluated to false, and not turned it into true.
  • at-rule(@charset) invalidates the whole rule here, rather than evaluating to false. That matches the RESOLVED line in issue #11116 ("at-rule(@charset) is invalid") more closely than the spec's note, which says only that @charset "is not considered to be supported". In practice the difference is whether an or next to it can still rescue the rule. Avoid testing for @charset.
  • The position-visibility results match BCD for Chrome: the old anchors-visible only.
  • single-axis-scroll-container is false in 152, consistent with BCD's Chrome 154.

Everything about Firefox and Safari in this piece comes from release notes, bug trackers and BCD, not from my own runs.

What I'd put in a design-system policy

Short version, for the wiki page:

  • Gate on the compat key you use, not the feature group. Check by_compat_key in a pinned web-features version, in CI.
  • Never use @supports to identify a browser. not selector(::-webkit-scrollbar) stopped matching Firefox in 153 and matched it again from 156; on the 153 ESR branch it may still not.
  • Write positive tests, with fallbacks outside the block. Avoid not around anything newer than the oldest engine you support. Combine at-rule() with a declaration test using or.
  • Treat named-feature() false as unknown. Use it only for opt-in enhancements, and copy the name from the spec.
  • Use the one-argument CSS.supports() when script needs to agree with your stylesheet.
  • Re-run a small detection matrix on each engine's release and keep the results with dates. Most of the answers in this piece changed during 2026.

What we don't know

  • When Safari ships at-rule() and named-feature(). Both landed on WebKit's main branch in August 2026 (bug 235400, bug 320705). BCD lists at-rule() as Safari Technology Preview and named-feature() as unsupported. WebKit has no stated position on named-feature(). A Safari release note would settle it. The Chrome Platform Status entry for at-rule() says Safari is shipping; I found no release that supports that.
  • Whether Firefox ESR 153 kept the "always true" behavior. BCD lists 153 as an ESR, and 153 is the release where selector(::-webkit-scrollbar) returned true on every site. I didn't find whether the 155 or 156 changes were uplifted to the ESR branch. Running the test in a current ESR 153 build would answer it.
  • Whether @supports and CSS.supports() ever disagree in Firefox or Safari. I measured one Chromium build. The matrix above, run in Firefox 158 and Safari 27, is the missing evidence.
  • When anchor positioning becomes Baseline. Chrome's rename targets milestone 157, scheduled for stable on 3 November 2026, though on 18 October the M157 feature list shows the entry under both "Enabled by default" and "In developer trial". Even after Chrome ships, BCD records no Firefox support for anchor-valid or anchor-visible, so by the Baseline definition the feature stays limited until Firefox ships them, unless web-features adds an override.
  • What happened to align-content-on-display-block. It was resolved as the first named feature in July 2024 and appears in the explainer, but not in the Editor's Draft list. I didn't find the decision that removed it.
  • How engines should evaluate at-rule(@charset). The issue resolution says "invalid" and the spec note says "not considered to be supported". The Chromium build I tested treats it as invalid. A WPT test for it would settle the interop question.
  • What @supports-condition will be called, and when anyone implements it. The name is an open inline issue in the draft, and no engine, BCD file or web-features entry tracks it yet.

Notes

  1. The same Editor's Draft still carries an older inline issue in its scrolling section, "Transforms have the same issue as scrolling, so Anchor Positioning similarly doesn't pay attention to them normally. Can we go ahead and incorporate the effects of transforms here?" The anchor-box text and the named feature's definition in Conditional Level 5 both describe the newer behavior, so I read the inline issue as stale. ↩︎

References

  1. CSS Conditional Rules Module Level 5 - Extensions to the @supports rule (Editor's Draft, 8 October 2026). CSS Working Group. Accessed .
  2. CSS Conditional Rules Module Level 5 - At-rules (definition of support). CSS Working Group. Accessed .
  3. CSS Conditional Rules Module Level 5 - Named features. CSS Working Group. Accessed .
  4. CSS Conditional Rules Module Level 5 - The @supports-condition rule. CSS Working Group. Accessed .
  5. CSS Conditional Rules Module Level 5 - Changes. CSS Working Group. Accessed .
  6. CSS Conditional Rules Module Level 3 - Definition of support (Editor's Draft, 8 October 2026). CSS Working Group. Accessed .
  7. CSS Conditional Rules Module Level 3 - Feature queries: the @supports rule. CSS Working Group. Accessed .
  8. CSS Conditional Rules Module Level 3 - The CSS namespace, and the supports() function. CSS Working Group. Accessed .
  9. CSS Conditional Rules Module Level 4 - Extensions to the definition of support (selector()). CSS Working Group. Accessed .
  10. Selectors Level 4 - Appendix B: Obsolete but Required -webkit- Parsing Quirks (Editor's Draft, 18 September 2026). CSS Working Group. Accessed .
  11. CSS Cascading and Inheritance Level 5 - Conditional @import rules. CSS Working Group. Accessed .
  12. CSS Anchor Positioning Module Level 1 - position-visibility (Editor's Draft, 6 September 2026). CSS Working Group. Accessed .
  13. CSS Anchor Positioning Module Level 1 - Anchor box. CSS Working Group. Accessed .
  14. csswg-drafts #3559: testing support of properties and values with partial implementations. CSS Working Group (GitHub). Accessed .
  15. csswg-drafts #9875: choose names for keyword-based feature queries in @supports and names for initial set of queries. CSS Working Group (GitHub). Accessed .
  16. csswg-drafts #2463: Feature detection for descriptors. CSS Working Group (GitHub). Accessed .
  17. csswg-drafts #6966: Add ability to test for at-rule preludes. CSS Working Group (GitHub). Accessed .
  18. csswg-drafts #11116: Behavior of @supports(at-rule(@import)). CSS Working Group (GitHub). Accessed .
  19. csswg-drafts #12622: @supports-condition, for larger feature queries and named reuse. CSS Working Group (GitHub). Accessed .
  20. csswg-drafts #10201: [css-anchor-position] Details on "anchors-valid". CSS Working Group (GitHub). Accessed .
  21. named-feature() explainer (L. David Baron, January 2026). CSS Working Group (GitHub). Accessed .
  22. Chrome Platform Status: at-rule: CSS Feature Detection. Chrome Platform Status. Accessed .
  23. Chrome Platform Status: named-feature() function for CSS @supports. Chrome Platform Status. Accessed .
  24. Chrome Platform Status: Ship anchor-visible and anchor-valid, and deprecate the plural versions. Chrome Platform Status. Accessed .
  25. Chromium Dash: milestone 157 schedule. Chromium. Accessed .
  26. Firefox 147 release notes for developers. MDN. Accessed .
  27. Firefox 151 release notes for developers. MDN. Accessed .
  28. Firefox 153 release notes for developers. MDN. Accessed .
  29. Firefox 155 release notes for developers. MDN. Accessed .
  30. Firefox 156 release notes for developers. MDN. Accessed .
  31. Firefox 157 release notes for developers. MDN. Accessed .
  32. BCD browsers/firefox.json (release dates and ESR status). MDN browser-compat-data. Accessed .
  33. BCD browsers/chrome.json (release dates). MDN browser-compat-data. Accessed .
  34. BCD browsers/safari.json (release dates). MDN browser-compat-data. Accessed .
  35. BCD css/at-rules/supports.json. MDN browser-compat-data. Accessed .
  36. BCD css/properties/position-visibility.json. MDN browser-compat-data. Accessed .
  37. web-features 3.43.0 data.json. WebDX Community Group. Accessed .
  38. web-features on the npm registry. npm. Accessed .
  39. web-features: Baseline status definition. WebDX Community Group. Accessed .
  40. web-features: Guidelines - Status overrides. WebDX Community Group. Accessed .
  41. Web Platform Status: Anchor positioning. Web Platform Status (webstatus.dev). Accessed .
  42. Web Platform Status: at-rule(). Web Platform Status (webstatus.dev). Accessed .
  43. Web Platform Status: named-feature(). Web Platform Status (webstatus.dev). Accessed .
  44. Web Platform Status: Anchor positioning transforms. Web Platform Status (webstatus.dev). Accessed .
  45. Web Platform Status: anchors-valid and anchors-visible. Web Platform Status (webstatus.dev). Accessed .
  46. Web Platform Status: @scope. Web Platform Status (webstatus.dev). Accessed .
  47. Web Platform Status: scrollbar-color. Web Platform Status (webstatus.dev). Accessed .
  48. WebKit Features for Safari 27.0. WebKit. Accessed .
  49. WebKit bug 235400: Implement at-rule function for use with @supports. WebKit Bugzilla. Accessed .
  50. WebKit bug 320705: [css-conditional-5] Support @supports named-feature(). WebKit Bugzilla. Accessed .
  51. WebKit standards-positions #600: named-feature() function for CSS @supports. WebKit (GitHub). Accessed .
  52. Mozilla standards-positions #1340: named-feature() function for CSS @supports. Mozilla (GitHub). Accessed .
  53. Mozilla standards-positions #1310: CSS AtRule feature detection. Mozilla (GitHub). Accessed .
  54. Mozilla bug 2042977: Implement named-feature() function for @supports rule. Mozilla Bugzilla. Accessed .
  55. scrollbar-color - CSS reference. MDN. Accessed .
  56. @supports - CSS reference. MDN. Accessed .

Found this useful? Pass it on.

Set in Archivo on a twelve-column grid. Built with Lit web components and rendered to static HTML.

© 2026 Oleg Chursin
Brooklyn, New York