Oleg
Chursin
WorkNotesPhotography
How a web feature becomes real: Living Standards, the Rec track, incubation and TC39 stages

What each standards label actually promises, from Living Standard to TC39 Stage 4, and how to weigh them before you build on a feature that is not Baseline yet.

Contents · 11 sections

A design review, a new dependency, and a sentence that ends the argument: "it's in the spec." Sometimes that sentence is about an HTML feature that every engine shipped years ago. Sometimes it's about a W3C document whose status section still promises a date from early 2025. Sometimes "the spec" is a Community Group draft that its own header says is not on any standards track. And sometimes it's a TC39 proposal that was at Stage 3 last spring and isn't any more.

The obvious fix is to ask for the label: Living Standard, Candidate Recommendation, Stage 3, phase 4. That's better, but it's still incomplete, because each of the five venues that produce the web platform's specifications uses its labels to promise different things. A WHATWG addition promises that implementers said they were interested. A W3C Candidate Recommendation Snapshot is partly a patent milestone. A WICG draft promises a venue. TC39 Stage 4 is the only label in the set that requires shipping code. A WebAssembly phase describes the state of a forked spec repository.

This piece reads each process document as if it were a spec, then checks the labels against what five real features actually look like on one day. In the first part of this series the question was what Baseline guarantees. Here it's the step before that: what each label tells you about the odds that an API will change, or that you'll be stuck on one engine. Everything below was checked on October 18, 2026.

"It's in the spec" is five different claims

The web platform doesn't have a standards body. It has at least five, and they divide the work roughly like this. The WHATWG maintains HTML, DOM, Fetch, Streams and a few more as Living Standards. W3C Working Groups run documents along the Recommendation track: WebGPU, most of CSS, and many APIs. The Web Platform Incubator Community Group (WICG) hosts drafts that aren't standards yet. Ecma's TC39 owns the JavaScript language and its stages. The WebAssembly Community Group and Working Group run their own phases on top of the W3C process.

Each venue answers the same three questions in a different order. When is the design considered finished? When do implementations have to exist, and how many? And who decides that the thing is done? The answers don't line up, which is why "Stage 3" and "Candidate Recommendation" sound equivalent and aren't.

I'll take the venues one at a time, quoting their process documents only where the exact wording carries weight. Then I'll put five features side by side, and end with the ladder I'd use when someone wants to build on something that isn't Baseline yet.

A Living Standard records agreement, not shipping

The WHATWG's rules for new features are in its Working Mode, under Additions. An addition "must have the support of at least two implementers", and the parenthetical that follows matters as much as the rule: that support "is not binding in any way on the implementers". The document then strongly recommends three more things. The support should sound like an intention to implement soon rather than general approval. There should be no strong objections from other implementers. And a prototype should already exist, or be written in parallel with the spec change.

So the bar for entering a Living Standard is interest, plus usually a prototype. Shipping isn't part of it. The general criteria for any normative change add tests (normally in web-platform-tests) and require filing implementation bugs against every engine that fails them. That last rule is useful to you as a reader: a merged WHATWG change should leave a trail of bugs, one per lagging engine, that you can go and read.

Risky changes are merged on the assumption they'll work

The Working Mode is candid about compatibility risk. Under Risky changes, it says that when several implementers are changing their engines with the intent to ship, the change should be merged on the assumption it succeeds, and reverted later if it turns out not to be web-compatible. When only one implementation is leading, the guidance flips: wait until one deployed implementation has seen significant user testing. Its example is the removal of mutation events, which wasn't merged until Chromium had shipped the removal to stable for a month.

Read that as a statement about what the text is. The Living Standard is the editors' best record of where the engines are converging. It can be ahead of every shipping browser, and it can be wrong in a way that gets reverted.

The editor decides, and implementations can overrule

The WHATWG FAQ on consensus says the group aims for rough, informal consensus, after which the editor of each standard makes the call. Someone who disagrees with the editor can appeal to the Steering Group, which has a formal consensus policy. The Working Mode's section on conflicts adds the blunt version: implementations can always override the editor by implementing something else. That's not a loophole; it's the design. A Living Standard that describes behavior nobody ships is what the Working Mode's editor section calls fiction: the editor's job includes the "don't write fiction" rule.

That also explains the stability story. The FAQ's answer to whether the standards can change at any time is no: once parts mature and ship, they generally can't change in backwards-incompatible ways without extreme care and implementer commitment. Stability attaches to shipped behavior, not to the document. On the patent side, the FAQ explains that roughly every six months each Living Standard is snapshotted into a Review Draft for patent review, so a Living Standard does have dated checkpoints. They aren't the thing most people link to.

Stages are optional, and say more than the merge does

For contributors who want more formal signals than the Working Mode gives, the WHATWG also runs an optional, opt-in Stages process, modeled loosely on TC39's and meant mostly for medium-to-large changes. Stage 1 needs one implementer's support, Stage 2 needs two and a draft spec with full algorithms, Stage 3 means a ready-for-review pull request with "comprehensive tests", and Stage 4 means the editor merged it. The page is explicit that a positive signal to advance doesn't commit anyone to the next stage, and that stages can regress if an implementer withdraws support.

The stage labels live on GitHub issues ("stage: 2" and so on). For features that use the process, the label on the issue tells you more about implementer commitment than the presence of text in the standard.

In the Living Standard, shipped by one engine

Speculation rules are the case I'd show anyone who treats the HTML Standard as a shipping list. The rules were incubated in the WICG, and the WICG draft is now a one-page stub titled "Moved to the HTML Standard" that points at HTML's Speculative loading section. The upstreaming happened in whatwg/html PR #11426, merged on September 10, 2025.

The PR's checklist shows the Working Mode at work. The box "At least two implementers are interested (and none opposed)" is ticked, listing Chromium, a Gecko comment, and a WebKit comment described as support for "a subset of the functionality". Implementation bugs are filed for Gecko and WebKit. The comments it links are measured: the Gecko one says Mozilla is interested in supporting speculation rules, and the WebKit one calls conservative same-origin prefetch "totally reasonable". Meanwhile Mozilla's position issue, #620, is closed with "position: neutral" and "concerns: complexity" labels, and WebKit's #54 is open with no position label.

More than a year after the merge, webstatus.dev lists speculation rules as limited, with only Chrome 109 and Edge 109. Nothing in that sequence broke a rule. Two implementers were interested, the text landed, and one engine ships it.

Three more examples from the current HTML Standard (last updated October 16, 2026) make the same point from different angles. Scoped custom element registries are in the standard and limited on webstatus.dev: Chrome 146, Edge 146 and Safari 26, no Firefox. setHTML() is in the standard, and the Sanitizer API feature is limited, with Chrome 146 and Firefox 148 and no Safari. The Navigation API's precommitHandler option is in the standard and was listed among the Interop 2026 focus areas, which tells you the engines still had work to do on it this year.

A W3C label is a patent milestone as much as a maturity level

The W3C's rules live in the Process Document, whose current version is dated August 18, 2025. Section 6.3.1 lists the maturity stages on the Recommendation track: Working Draft, Candidate Recommendation and W3C Recommendation, plus the end-of-life statuses (superseded, obsolete, rescinded, discontinued).

A Working Draft is the loosest of these. The Process says it doesn't necessarily represent Working Group consensus and implies no endorsement beyond agreement to work on the area. Editor's Drafts, which is where most people actually read W3C specs, are looser still: the Process gives them "no official standing whatsoever".

Snapshot and Draft are not two names for the same thing

A Candidate Recommendation is where the Process says a document is considered complete and fit for purpose, with no further refinement expected without implementation experience. It comes in two forms, and the difference is legal before it's technical.

A Candidate Recommendation Snapshot (CRS) corresponds to a Patent Review Draft under the W3C Patent Policy, and publishing one triggers a Call for Exclusions. Publishing a Snapshot also needs Team verification of a transition or update request. A Candidate Recommendation Draft (CRD) is published to collect review of changes since the last Snapshot, with process requirements kept minimal so the group can keep the document current. The Process says a CRD gives no exclusion opportunity and counts as a Working Draft for patent purposes.

In other words, the word "Candidate" in a CRD's title describes the last Snapshot, and the text you're reading may include changes that have had no patent review and no Team verification. The Process does say changes in a CRD should be at Snapshot quality. That's an expectation, not a gate.

Proposed Recommendation is gone

If you learned the track as WD, CR, PR, REC, one step has disappeared. The 2025 Process lists Proposed Recommendation as a retired term, last defined in the 2023 Process, and its change log explains why: PR was only a short-lived transition during which verifications and votes happened, and those can now be done on a CR directly. The change log says this doesn't alter the quality or consensus expectations.

What does it take to become a Recommendation? The transition requirements ask the group to show "adequate implementation experience", wide review, and formal responses to every issue raised during the CR period, after which an Advisory Committee review of at least 28 days follows. There's an exception the Team can grant for minimal implementation experience, with published reasons. The Process doesn't put a number on "adequate". Its implementation experience section lists questions the Team considers, such as whether every feature is implemented and whether there are independent interoperable implementations, without making two implementations a hard rule.

WebGPU: the boilerplate lags the document

WebGPU is a good stress test. The current W3C version is a Candidate Recommendation Draft dated September 15, 2026. Its status section says the document "will remain a Candidate Recommendation at least until 28 February 2025". That date is long past. The sentence isn't wrong, exactly (it's a minimum), but it's the kind of status text that goes stale without anyone editing it.

The publication history is more informative than the status section. I counted 458 entries on October 18: the First Public Working Draft on May 18, 2021, then 399 Working Drafts, exactly one Candidate Recommendation Snapshot on December 19, 2024, and 57 Candidate Recommendation Drafts since. So the patent-reviewed text is almost two years old, and everything after it is a draft in the patent sense.

The same status section says the group expects to show each feature implemented in at least two deployed browsers on modern GPU APIs. On webstatus.dev WebGPU is still limited: Chrome 144, Chrome Android 121, Edge 144 and Safari 26. There's no Firefox line because MDN's compat data marks Firefox 141 as a partial implementation: Windows since 141 and Apple-silicon Macs since 145 or 147, but no Linux and no Intel Macs. (Part 1 of this series walks through that Firefox entry.) The W3C label says "complete and fit for purpose". The interop data says one core engine is short. Both are true, and they measure different things.

Incubation is a venue, not a stage

The WICG describes itself on its own home page as a forum for discussing and incubating ideas, and it says plainly that it isn't a standards body. The usual path it describes ends with advocating for adoption by the W3C or the WHATWG.

The specs say the same thing about themselves. Prioritized Task Scheduling, the spec behind scheduler.postTask() and scheduler.yield(), is a "Draft Community Group Report, 30 May 2025", and its status section says it is not a W3C Standard and not on the W3C Standards Track. Patent terms come from the Community Contributor License Agreement, which the document notes has a limited opt-out.

That draft also contains a section titled "Modifications to Other Standards", with patches to the HTML event loop. This is typical. An incubation often can't stand alone; it describes changes to a Living Standard it doesn't control. Until those patches land upstream, the incubated feature depends on text that isn't in the HTML Standard.

Graduation is visible, and partial

When incubation works, it leaves a stub, like the speculation rules example above. It can also graduate in pieces. PR #11426's description says it does not port the navigational prefetching algorithms, which remain in the WICG's separate prefetch document. So a reader of the HTML Standard sees speculation rules, while part of what makes them do anything is still in an incubation draft.

Chromium's own launch process explains why Chromium-led drafts tend to start there. The Launching features page tells feature owners that, by the "widen review" step, their explainer should have moved to an incubation venue or a working group, and names the WICG as a good default. Later, at "prepare to ship", it says there is no requirement that a working group adopt a feature before Chromium ships it. If the spec is still in incubation, the owner is told to propose migration and to declare publicly that incubation is finished.

Put those together and "it's a WICG spec" mostly tells you one thing: at least one engine wanted a public, IP-covered place to write the design down. It tells you nothing about whether other engines agree.

TC39 is the only venue whose final stage requires shipping code

The TC39 process document defines six stages: 0, 1, 2, 2.7, 3 and 4. The committee operates by consensus and must approve every advancement. The definitions are precise enough to quote.

At Stage 2 the committee has picked a preferred solution, but the design is a draft and "may still change significantly". At Stage 2.7 the proposal is approved in principle and the solution is complete; the committee won't request changes except those that come out of testing, implementation or usage. Entering 2.7 requires complete spec text signed off by assigned reviewers and the editors, and Test262 tests should be written during this stage. At Stage 3 the proposal is "recommended for implementation", and changes are expected only from web incompatibilities or feedback from production-grade implementations. At Stage 4 it's complete and ready for the standard.

The Stage 4 entrance criteria are the strictest of any venue in this piece: two compatible implementations that pass Test262, significant in-the-field experience with shipping implementations, a pull request to ecma262 (or ecma402) with the integrated spec text, and editor sign-off on that pull request. No other label here demands that code has shipped.

Stage 2.7 is relatively new. The tc39/proposals README gained its Stage 2.7 section in a February 2024 commit that moved ShadowRealm into it. If you remember Stage 3 meaning "design done, now write tests", that's what 2.7 means today; Stage 3 now assumes the tests exist.

Stages go backwards

The process allows regression, and it happens to proposals people use. The commit history of the proposals list records "ShadowRealms demoted to stage 2, per 2023.09 TC39", followed by the 2024 move to 2.7. More recently, a commit on May 19, 2026 reads "Decorators to stage 2.7, per 2026.05.19 TC39", and its diff moves Decorators out of the Stage 3 table. As of October 18 the README lists Decorators, Decorator Metadata and ShadowRealm at Stage 2.7, and Deferring Module Evaluation, Source Phase Imports and Import Text among the Stage 3 proposals.

The meeting notes for May 19 say why, and the reasons are the useful part. The presenter, from Mozilla, pointed out that Decorators had been at Stage 3 since March 2022 and no engine had a shipping implementation. SpiderMonkey's partial implementation needed rework and wouldn't resume until another engine shipped; the JavaScriptCore representative said much the same; V8 had stopped work on a contributed implementation because of open spec bugs and missing Test262 coverage. The recorded summary is that engines "raised concerns about incomplete tests, spec issues, and implementation complexity", and that larger design changes might later send it back to Stage 2. Decorator Metadata followed it to 2.7 later the same day.

If you write decorators through a transpiler today, that's the part to sit with. The notes describe a proposal in the state 2.7 was invented for: spec text written but with known bugs, tests incomplete, engines waiting on each other. It had carried the Stage 3 label for four years. The notes also record that when 2.7 was introduced, existing Stage 3 proposals were explicitly not moved back. A Stage 3 label older than February 2024 never had to pass the 2.7 gate.

Stage 4 is not the same as "in the spec you read"

TC39 publishes one edition a year. The process document's timeline: a candidate draft on February 1, a 60-day royalty-free opt-out period, Stage 4 proposals incorporated and the new edition branched at the March meeting, Ecma review from April to June, and General Assembly approval in July.

Temporal is the current example of how that timeline interacts with a big proposal. The proposals repository records "Temporal to stage 4, per 2026.03.11 TC39", and Explicit Resource Management followed on May 19. The finished-proposals list gives both an expected publication year of 2027. The Temporal spec text reads "Stage 4 Draft / July 27, 2026".

The ECMA-262 draft is where the two diverge. The draft dated October 16, 2026, titled ECMAScript 2027, contains a DisposableStack Objects section, so Explicit Resource Management has been merged. I searched the same draft for Temporal and found no Temporal sections; the only matches were two grammar symbols, TemporalDecimalFraction and TemporalDecimalSeparator, in the time zone offset string grammar. The merge is still open as ecma262 PR #3966, "Temporal stage 4, round 2", opened on September 1, 2026 to replace an earlier PR whose review thread had grown too long to navigate.

So a Stage 4 proposal can sit outside the draft specification for months, and "no further changes" isn't quite literal while it does. At the May 2026 meeting, two months after Stage 4, the Temporal champion asked for consensus on two normative one-line fixes for rare time zone and duration rounding edge cases, several of them found by Firefox's fuzzing. Both got consensus, and two more issues were still under investigation. The same presentation said the open ECMA-262 and ECMA-402 pull requests, not the proposal repository, were the source of truth until the merge. For you as a user these are corner cases. If you cite the spec, cite the PR.

Stage 4 needs two engines, Baseline needs three

The arithmetic is the most useful thing in this section. Stage 4 requires two compatible implementations. Baseline needs every core browser, which in practice means three engines. On webstatus.dev, Temporal is limited: Firefox 139 and Chrome 144, no Safari. Explicit resource management is limited for the same reason: Chrome 134 and Firefox 141, no Safari. Both are finished, by the strictest definition of finished in this article, and neither is usable without a plan for Safari.

Wasm phases describe the spec repository, not your users

The WebAssembly process is a W3C process document of its own, kept in the meetings repository as phases.md. Phase 0 belongs to an individual contributor, phase 1 to the Community Group, phases 2 and 3 to the Community and Working Groups together, and phases 4 and 5 to the Working Group. Advancement is a CG vote on whether the next phase's entry requirements are met, and the document says proposals should back up a phase if consensus falls apart.

The interesting phases are the last three. At phase 3, the implementation phase, engines implement, the spec text in the forked repository gets full prose and formalization, the reference interpreter is updated, toolchains implement, and open questions get resolved, all in parallel. Entering phase 4 requires two or more web VMs that pass the test suite, at least one toolchain, a fully updated spec and reference interpreter, and CG consensus that the specification is complete. The document's note at this point is that the proposal is "basically frozen". Phase 5 needs Working Group consensus that the feature is complete, after which editors merge it into the main spec.

That makes Wasm phase 4 the closest analogue to TC39 Stage 4, but with "implemented and passing tests" rather than "shipping with significant in-the-field experience". Both count engines, not browsers: Wasm asks for two web VMs, and TC39's in-the-field criterion gives "two independent VMs" as its example. That matters when one engine powers several browsers: on that reading, Chrome and Edge shipping the same V8 is one implementation, not two.

JSPI matches its phase, threads don't

The WebAssembly proposals tracker on October 18 lists JS Promise Integration (JSPI) at phase 5, not yet merged; ESM Integration at phase 3; and the Component Model at phase 1. (A small naming wrinkle: the tracker calls phase 2 "Proposed Spec Text Available", while phases.md calls it "Feature Description Available". Same phase.)

JSPI behaves the way the labels suggest. It's at phase 5, and webstatus.dev has it newly available since September 14, 2026, with Chrome 137, Firefox 153 and Safari 27. Label and interop agree.

Threads don't. The tracker still lists Threads at phase 4. webstatus.dev says threads and atomics are widely available, with a low date of December 13, 2021 and a high date of June 13, 2024. A feature can sit below the final phase for years after every engine shipped it, because the remaining work is in the spec repository and the W3C process, not in browsers. If you read phase numbers as a proxy for "can I use it", threads will mislead you in the cautious direction.

Each venue puts "two implementations" somewhere else

Lay the five processes next to each other and the same milestone shows up at a different point in each. Fig. 1 does that, with three rows: the point where the design is treated as frozen, the point where two implementations are required, and the point where the venue calls the thing done.

For the WHATWG, the design is frozen in practice once implementations ship, and the two-implementer requirement is about interest before the merge. For the W3C, the design should be complete at Candidate Recommendation, and implementation experience is checked at the move to Recommendation, without a fixed count. The WICG has no gate at all. TC39 freezes the design at 2.7 and demands two shipping implementations at 4. Wasm freezes at 4, and requires two VMs to get there.

Intents and positions move before any label does

When the labels lag, two kinds of public record run ahead of them: an engine's own launch intents, and the other engines' published positions.

Chromium's Launching features page lays out the sequence for a new feature. An Intent to Prototype email to blink-dev starts flag-guarded code. Dev Trials invite developers to try it. During the widen-review step, owners should request signals from other browser vendors and web developers "at least a month" ahead of an Intent to Ship. An optional origin trial runs for at most 12 milestones initially, with extensions of up to 6 milestones at a time that require progress on a draft spec, TAG review, signals requests and WPT tests. The Intent to Ship needs three LGTMs from API owners before the feature can be enabled by default, and owners are told to keep the target milestone in ChromeStatus current.

None of this is a standards process. It's one implementer's governance. But it's public, and it produces dated records that the standards labels don't.

Reference Target: an estimate, a ship date, and spec PRs still open

Reference Target, which lets a shadow root forward ID references such as <label for> and aria-labelledby to an element inside it, is a clean recent case. The Intent to Ship, posted on June 23, 2026, lists the specification as two open pull requests, one to HTML and one to DOM. It records the Gecko signal as positive and WebKit as "No signal", mentions an origin trial in Chrome 133 to 135 with little developer uptake, and estimates shipping in milestone 151 on desktop, Android and WebView. Three LGTMs were posted in the thread on June 30. The first came with a condition: "Please make sure the PRs land," and delay shipping if the final review changes the API shape.

Here's what happened next. Chrome Platform Status now records the shipping stage at milestone 152 for desktop, Android and WebView, one later than the intent's estimate. MDN's compat data agrees: ShadowRoot.referenceTarget lists Chrome 152, with Firefox 144 and Safari 26 behind preferences, and marks the feature experimental and not on a standards track. Chromium Dash puts the M152 stable date at August 25, 2026, four weeks after M151's July 28.

And the spec PRs? On October 18 both whatwg/html #10995 and whatwg/dom #1353 are still open. The positions haven't moved either: Mozilla's issue #1035 is closed with "position: positive", and WebKit's issue #356 is open with topic and venue labels but no position. Fig. 2 puts those dates on one line.

Two lessons, both small and both useful. An intent's milestone is an estimate, and the record of what shipped lives in ChromeStatus and BCD. And "shipped in Chrome" can precede "in the standard" by months even when an API owner asked for the order to be the other way round. For a dependency decision, the open PRs are the risk: they're where a shape change would come from. (There's a small inconsistency in ChromeStatus itself. Its per-feature status text still says "Origin trial" next to the milestone 152 shipping stage. Part 1's method says to trust the milestone, and BCD supports that reading.)

Positions can stay open for years

For the engine you're missing, its published position is the better leading indicator. WebKit's position issue on Prioritized Task Scheduling, #361, was opened on June 7, 2024. On October 18, 2026 it is still open, with venue and origin labels and no position label, and its last update was in July 2024. Mozilla, by contrast, closed its scheduler.yield() position as positive, and webstatus.dev shows Firefox shipping the Scheduler API in 142.

An open issue with no label isn't a "no". It's an absence of information. For planning, I'd read it as a sign of a long limited period, and give it more weight than anything in Chromium's own process.

Interop turns a mature label into a test score

The Interop project is the one place where the labels feed directly into shared engineering work. WebKit's call for Interop 2027 proposals names two essential criteria for a focus area, testability and web standards, and says that without "a mature web standard (from the W3C, TC39, etc)" an idea is too early. Submissions ran from September 3 to September 23, 2026.

So a label does unlock something concrete: eligibility for a year of coordinated test-driven work across engines. It isn't a guarantee of identical behavior, though. Looking back at Interop 2025, Mozilla's Interop 2026 launch post says that in some focus areas, naming CSS anchor positioning and the Navigation API, it was possible to score well on the tests while behaving inconsistently, partly because of missing tests and partly because some tests contradicted the spec. Both areas are back in 2026 as reliability work. Labels feed tests; tests don't cover everything.

The most final label in the table is still limited

Here are five features that a team might want to depend on today, each from a different venue, all checked on October 18, 2026. Shipping versions and Baseline status are from webstatus.dev; labels are from each venue's own documents, linked above.

Feature Venue and label Shipping (desktop) Baseline
Navigation API WHATWG HTML, Living Standard Chrome 102, Safari 26.2, Firefox 147 Newly available, 2026-01-13
WebGPU W3C, CR Draft of 2026-09-15 (one Snapshot, 2024-12-19) Chrome 144, Safari 26; Firefox partial Limited
scheduler.yield() WICG, Draft CG Report of 2025-05-30 Chrome 129, Firefox 142 Limited
Temporal TC39, Stage 4 (March 2026), expected ES2027 Firefox 139, Chrome 144 Limited
JSPI Wasm CG/WG, phase 5 Chrome 137, Firefox 153, Safari 27 Newly available, 2026-09-14

Two of the five are Baseline. One of those is a Living Standard feature that Chrome shipped in 2022 and the last engine shipped in January (Navigation API on webstatus.dev); the other is at the last phase of its process. Of the three limited ones, the one with the most final-sounding label, Temporal at Stage 4, is in the same position as the WICG draft: two engines out of three. Fig. 3 animates the table so you can watch the label column and the Baseline column fail to line up.

You can rerun the Baseline half of the table yourself. This script reads the same webstatus.dev API I used; I ran it on Node 24.18.0 on October 18, and its output matched the table.

feature-status.mjs
// Node 18+ (global fetch). Prints Baseline status and missing core
// browsers for each web-features id, as webstatus.dev reports them.
const features = [
  'navigation', 'webgpu', 'scheduler', 'temporal', 'wasm-jspi'
];
const core = [
  'chrome', 'chrome_android', 'edge', 'firefox',
  'firefox_android', 'safari', 'safari_ios'
];

for (const id of features) {
  const res = await fetch(`https://api.webstatus.dev/v1/features/${id}`);
  if (!res.ok) throw new Error(`${id}: HTTP ${res.status}`);
  const { baseline, browser_implementations: impl = {} } =
    await res.json();
  const missing = core.filter((b) => !impl[b]);
  console.log(
    id.padEnd(11),
    (baseline?.status ?? 'unknown').padEnd(8),
    baseline?.low_date ?? '-',
    missing.length ? `missing: ${missing.join(', ')}` : ''
  );
}

On that day it printed newly with 2026-01-13 for navigation and 2026-09-14 for wasm-jspi, and limited for the other three, missing Firefox (both platforms) for webgpu and Safari (both platforms) for scheduler and temporal. The script doesn't know about labels; there's no machine-readable registry that covers all five venues. That half you still read by hand.

Trust a label on API shape, never on engine coverage

Here's the ladder I'd use, written as two separate risks, because they have different fixes. The first is that the API changes under you. The second is that you end up depending on one engine.

Shape risk falls as reviews and tests pile up

  • TC39 Stage 4, Wasm phase 4 or 5, and shipped WHATWG features: low. The processes freeze the design at these points and the engines that shipped carry compatibility weight. Changes after this are bug fixes, or happen through new proposals.
  • TC39 Stage 3, W3C CR with a recent Snapshot: low to moderate. Stage 3 only expects changes from web incompatibility or production feedback, but Decorators show it can still regress. A CR Draft may contain changes that haven't been through Snapshot review; check how old the last Snapshot is.
  • TC39 Stage 2.7, WHATWG Stage 2 or 3, Wasm phase 3: moderate. Designs are complete on paper and still waiting on tests or implementation feedback.
  • WICG drafts and open spec PRs: high, regardless of whether a browser shipped. Reference Target shipped with its spec PRs open; an LGTM explicitly allowed for the shape to change in the final review.
  • Editor's Drafts, explainers, TC39 Stage 1 or 2: assume it will change.

What reduces this risk: tests in WPT or Test262 that pin the behavior you use, a TC39 2.7 sign-off, a CR Snapshot, or a merged PR. In each case you're looking for a record that someone other than the champion reviewed the text you depend on.

No label protects you from single-engine lock-in

Stage 4 and phase 4 guarantee two engines, not three. A WHATWG merge records interest. W3C CR says nothing about who shipped. Only three things predict whether the third engine will arrive: a shipped implementation (BCD and webstatus.dev), a published position (Mozilla's and WebKit's standards-positions repositories), and implementation bugs that someone is actively working on. An open position issue with no label, like WebKit #361, means you should plan for a long wait.

Match the plan to the missing engine

If the feature is Baseline, follow the checks in part 1 and stop worrying about the label.

If the feature is limited, the label is Stage 4, phase 4 or a merged WHATWG change, and the missing engine has either a positive position or visible implementation work, ship it behind feature detection with a fallback that you test in the missing engine. Temporal is the example: finished, two engines, and BCD lists Safari as "preview", meaning Safari Technology Preview has it and no stable Safari does. Keep it behind one module so the fallback is in one place. Here's the pattern; I ran both branches on Node 24.18.0 on October 18, the Temporal one with --harmony-temporal.

today.mjs
// Temporal: TC39 Stage 4 since March 2026, limited on webstatus.dev
// (no Safari) as of 2026-10-18. Keep it behind one module.
export function today(timeZone) {
  if (globalThis.Temporal) {
    return Temporal.Now.plainDateISO(timeZone).toString();
  }
  const parts = new Intl.DateTimeFormat('en-US', {
    timeZone, year: 'numeric', month: '2-digit', day: '2-digit'
  }).formatToParts(new Date());
  const get = (type) => parts.find((p) => p.type === type).value;
  return `${get('year')}-${get('month')}-${get('day')}`;
}

If the missing engine has no position and the spec is an incubation, use it only where the fallback is the real product and the feature is an enhancement. scheduler.yield() is the textbook case: Chrome 129 and Firefox 142 ship it, WebKit hasn't said, and the fallback (yield with a macrotask) is what Safari users get until WebKit says something.

yield-to-main.js
// scheduler.yield() ships in Chrome (129) and Firefox (142), not Safari,
// per webstatus.dev on 2026-10-18. Elsewhere, fall back to a new task.
export function yieldToMain() {
  if (typeof globalThis.scheduler?.yield === 'function') {
    return globalThis.scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

The two branches aren't equivalent. The WICG draft's section on priorities says continuations have a higher effective priority than scheduler tasks of the same priority, while a setTimeout callback is an ordinary new task. That's a scheduling difference you should measure, not assume away, and PLT-04 and PLT-06 later in this track cover why.

If the feature only exists in one engine and its spec is a WICG draft or an open PR, treat it as a vendor API. That's not an insult; it's an accurate description of the risk. Budget for removal, wrap it, and watch both standards-positions repositories and the spec PRs.

And when someone in review says "it's in the spec", ask which venue, which label, which date, and who has shipped it. Each answer is a short lookup, and together they tell you more than the label does.

What we don't know

When Temporal lands in ECMA-262. It reached Stage 4 at the March 2026 meeting and is expected in ES2027, but on October 18 the merge PR, #3966, is still open and the October 16 draft has no Temporal sections. Under the process timeline, the deadline that matters is the March 2027 branch. I also didn't check whether the two issues the champion called "still under investigation" in May have since been resolved. What would settle both: the PR's merge commit and its fix-up history.

What the next Decorators design looks like. The May 19 notes record the reasons for the move to 2.7, but not a plan. Engine representatives talked about complexity and possible simplifications, the champion said they were open to going back to the drawing board, and the summary leaves Stage 2 on the table. I wouldn't guess at which parts of today's transpiled semantics survive.

Why Reference Target shipped in 152 rather than 151. The intent was posted on June 23, after the date Chromium Dash lists as M151's feature freeze (June 15), and the LGTMs came on June 30, the day after M151's branch point (June 29). That could explain a one-milestone slip. I found no statement saying so, and I'm not treating my inference as a fact.

Whether ChromeStatus's "Origin trial" status text for Reference Target is stale or means something. Its shipping stage and BCD both say Chrome 152. Confirming on a Chrome 152 stable build without flags or a trial token would settle it; I didn't run that test.

When WebGPU gets another CR Snapshot, and when it requests Recommendation. The status section's February 2025 date is a minimum that has long passed, and the W3C Process gives no deadline. On webstatus.dev's data, Chrome and Safari already make two deployed browsers, so the group's stated expectation looks met at the feature level; whether every feature passes in both, per the implementation report the status section promises, I didn't check.

How the WHATWG counted implementer interest for speculation rules. The PR's checklist lists Gecko interest and WebKit support for a subset, while Mozilla's position issue still says neutral. The Working Mode doesn't say whether "interested in a subset" counts toward two implementers. I read the merge as consistent with the rules, but the rules don't settle the edge case.

References

  1. WHATWG Working Mode. WHATWG. Accessed .
  2. WHATWG FAQ. WHATWG. Accessed .
  3. WHATWG Stages. WHATWG. Accessed .
  4. Add speculation rules prefetch (whatwg/html PR #11426). WHATWG. Accessed .
  5. HTML Standard: Speculative loading. WHATWG. Accessed .
  6. Speculation Rules (moved to the HTML Standard). WICG. Accessed .
  7. Speculation rules. Web Platform Status (webstatus.dev). Accessed .
  8. Mozilla standards position: Speculation Rules (issue #620). Mozilla. Accessed .
  9. WebKit standards position: Navigational prefetching and prerendering (issue #54). WebKit. Accessed .
  10. HTML Standard: Scoped custom element registries. WHATWG. Accessed .
  11. Scoped custom element registries. Web Platform Status (webstatus.dev). Accessed .
  12. HTML Standard: setHTML(). WHATWG. Accessed .
  13. Sanitizer API. Web Platform Status (webstatus.dev). Accessed .
  14. HTML Standard: precommitHandler. WHATWG. Accessed .
  15. W3C Process Document (18 August 2025): Maturity stages on the Recommendation track. W3C. Accessed .
  16. W3C Process Document: Implementation experience. W3C. Accessed .
  17. W3C Process Document: Transitioning to Recommendation. W3C. Accessed .
  18. W3C Process Document: Changes since the 3 November 2023 Process. W3C. Accessed .
  19. WebGPU - W3C Candidate Recommendation Draft, 15 September 2026. W3C GPU for the Web Working Group. Accessed .
  20. WebGPU publication history. W3C. Accessed .
  21. BCD api/GPU.json. MDN. Accessed .
  22. WebGPU. Web Platform Status (webstatus.dev). Accessed .
  23. Web Incubator Community Group. WICG. Accessed .
  24. Prioritized Task Scheduling - Draft Community Group Report, 30 May 2025. WICG. Accessed .
  25. Scheduler API. Web Platform Status (webstatus.dev). Accessed .
  26. WebKit standards position: Prioritized Task Scheduling (issue #361). WebKit. Accessed .
  27. Mozilla standards position: scheduler.yield() (issue #1039). Mozilla. Accessed .
  28. The TC39 Process. Ecma TC39. Accessed .
  29. tc39/proposals: active proposals. Ecma TC39. Accessed .
  30. tc39/proposals commit: Decorators to stage 2.7, per 2026.05.19 TC39. Ecma TC39. Accessed .
  31. TC39 meeting notes, 19 May 2026. Ecma TC39. Accessed .
  32. tc39/proposals commit: ShadowRealms demoted to stage 2, per 2023.09 TC39. Ecma TC39. Accessed .
  33. tc39/proposals commit: ShadowRealm to stage 2.7, per 2024.02.07 TC39. Ecma TC39. Accessed .
  34. tc39/proposals commit: Temporal to stage 4, per 2026.03.11 TC39. Ecma TC39. Accessed .
  35. tc39/proposals commit: Explicit Resource Management to stage 4, per 2026.05.19 TC39. Ecma TC39. Accessed .
  36. Finished proposals. Ecma TC39. Accessed .
  37. Temporal proposal spec text (Stage 4 Draft, July 27, 2026). Ecma TC39. Accessed .
  38. ECMAScript 2027 draft (October 16, 2026): DisposableStack Objects. Ecma TC39. Accessed .
  39. Temporal stage 4, round 2 (tc39/ecma262 PR #3966). Ecma TC39. Accessed .
  40. Temporal. Web Platform Status (webstatus.dev). Accessed .
  41. BCD javascript/builtins/Temporal.json. MDN. Accessed .
  42. Explicit resource management. Web Platform Status (webstatus.dev). Accessed .
  43. WebAssembly/proposals. WebAssembly Community Group. Accessed .
  44. WebAssembly W3C Process (phases). WebAssembly CG and WG. Accessed .
  45. JavaScript promise integration (WebAssembly). Web Platform Status (webstatus.dev). Accessed .
  46. Threads and atomics (WebAssembly). Web Platform Status (webstatus.dev). Accessed .
  47. Launching features. Chromium (Blink). Accessed .
  48. Intent to Ship: Reference Target. blink-dev. Accessed .
  49. Chrome Platform Status API: Reference Target for Cross-root ARIA. Chrome Platform Status. Accessed .
  50. Chromium Dash: milestone schedule for M152. Chromium. Accessed .
  51. Chromium Dash: milestone schedule for M151. Chromium. Accessed .
  52. BCD api/ShadowRoot.json. MDN. Accessed .
  53. Add reference target (whatwg/html PR #10995). WHATWG. Accessed .
  54. Add reference target to shadow root (whatwg/dom PR #1353). WHATWG. Accessed .
  55. WebKit standards position: Reference Target for Cross-Root ARIA (issue #356). WebKit. Accessed .
  56. Mozilla standards position: Reference Target for Cross-Root ARIA (issue #1035). Mozilla. Accessed .
  57. Submit your ideas for Interop 2027. WebKit blog. Accessed .
  58. Launching Interop 2026. Mozilla Hacks. Accessed .
  59. Navigation API. Web Platform Status (webstatus.dev). 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