diff --git a/src/content/blog/2025/04/01/react-labs-what-we-have-been-working-on-april-2025.md b/src/content/blog/2025/04/01/react-labs-what-we-have-been-working-on-april-2025.md
deleted file mode 100644
index 5426f4584ea..00000000000
--- a/src/content/blog/2025/04/01/react-labs-what-we-have-been-working-on-april-2025.md
+++ /dev/null
@@ -1,12993 +0,0 @@
----
-title: "React Labs: What We've Been Working On – April 2025"
-author: Ricky Hanlon, Lauren Tan, Mofei Zhang, Jordan Eldredge, Jack Pope, Matt Carroll
-date: 2025/04/01
-description: TODO
----
-
-April 1, 2025 by [Ricky Hanlon](https://twitter.com/rickhanlonii), and [Matt Carroll](https://twitter.com/mattcarrollcode).
-
----
-
-
-
-In React Labs posts, we write about projects in active research and development. In this post, we're sharing two new experimental features that are ready to try today, and updates on other areas we're working on now.
-
-
-
-
-
-
-React Conf 2025 is scheduled for October 7–8 in Henderson, Nevada!
-
-We're looking for speakers to help us create talks about the features covered in this post. If you're interested in speaking at ReactConf, [please apply here](https://forms.reform.app/react-conf/call-for-speakers/piaae1?ga4_visitor_id=c3e8f3ce-2004-47a5-b801-f6b308280acd) (no talk proposal required).
-
-For more info on tickets, free streaming, sponsoring, and more, see [the React Conf website](https://conf.react.dev).
-
-
-
-Today, we're excited to release documentation for two new experimental features that are ready for testing:
-
-- [View Transitions](#view-transitions)
-- [Activity](#activity)
-
-We're also sharing updates on new features currently in development:
-- [React Performance Tracks](#react-performance-tracks)
-- [Compiler IDE Extension](#compiler-ide-extension)
-- [Automatic Effect Dependencies](#automatic-effect-dependencies)
-- [Fragment Refs](#fragment-refs)
-- [Concurrent stores](#concurrent-stores)
-
----
-
-# New Experimental Features {/*new-experimental-features*/}
-
-View Transitions and Activity are now ready for testing in `react@experimental`.These features have been tested in production and are stable, but the final API may still change as we incorporate feedback.
-
-
-
-You can try them by upgrading React packages to the most recent experimental version:
-
-- `react@experimental`
-- `react-dom@experimental`
-
-Read on to learn how to use these features in your app, or check out the newly published docs:
-
-- [``](/reference/react/ViewTransition): A component lets you activate an animation for a Transition.
-- [`addTransitionType`](/reference/react/addTransitionType): A function that allows you to specify the cause of a Transition.
-- [``](/reference/react/Activity): A component that lets you hide and show part of the UI.
-
-## View Transitions {/*view-transitions*/}
-
-React View Transitions are a new experimental feature that makes it easier to add animations to UI transitions in your app. Under-the-hood, these animations APIs use the new [`startViewTransition`](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition) API available in most modern browsers.
-
-To opt-in to animating an element, wrap it in the new `` component:
-
-
-```js
-// "what" to animate.
-
-
animate me
-
-```
-
-This new component lets you declaratively define "what" to animate when an animation is activated.
-
-You can define "when" to animate by using one of these three triggers for a View Transition:
-
-```js
-// "when" to animate.
-
-// Transitions
-startTransition(() => setState(...));
-
-// Deferred Values
-const deferred = useDeferredValue(value);
-
-// Suspense
-}>
-
Loading...
-
-```
-
-By default, these animations use the [default CSS animations for View Transitions](https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API/Using#customizing_your_animations) applied (typically a smooth cross-fade). You can use [view transition pseudo-selectors](https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API/Using#the_view_transition_pseudo-element_tree) to define "how" the animation runs. For example, you can use `*` to change the default animation for all transitions:
-
-```
-// "how" to animate.
-::view-transition-old(*) {
- animation: 300ms ease-out fade-out;
-}
-::view-transition-new(*) {
- animation: 300ms ease-in fade-in;
-}
-```
-
-When the DOM updates due to an animation trigger—like `startTransition`, `useDeferredValue`, or a `Suspense` fallback switching to content—React will use [declarative heuristics](/reference/react/ViewTransition#viewtransition) to automatically determine which `` components to activate for the animation. The browser will then run the animation that's defined in CSS.
-
-If you're familiar with the browser's View Transition API and want to know how React supports it, check out [How does `` Work](/reference/react/ViewTransition#how-does-viewtransition-work) in the docs.
-
-In this post, let's take a look at a few examples of how to use View Transitions.
-
-We'll start with this app, which doesn't animate any of the following interactions:
-- Click a video to view the details.
-- Click "back" to go back to the feed.
-- Type in the list to filter the videos.
-
-
-
-```js src/App.js active
-import TalkDetails from './Details'; import Home from './Home'; import {useRouter} from './router';
-
-export default function App() {
- const {url} = useRouter();
-
- // 🚩This version doesn't include any animations yet
- return url === '/' ? : ;
-}
-```
-
-```js src/Details.js
-import { fetchVideo, fetchVideoDetails } from "./data";
-import { Thumbnail, VideoControls } from "./Videos";
-import { useRouter } from "./router";
-import Layout from "./Layout";
-import { use, Suspense } from "react";
-import { ChevronLeft } from "./Icons";
-
-function VideoInfo({ id }) {
- const details = use(fetchVideoDetails(id));
- return (
- <>
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js active
-import { useState, unstable_ViewTransition as ViewTransition } from "react"; import LikeButton from "./LikeButton"; import { useRouter } from "./router"; import { PauseIcon, PlayIcon } from "./Icons"; import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
-
- );
-}
-
-```
-
-```js src/Icons.js hidden
-export function ChevronLeft() {
- return (
-
- );
-}
-
-export function PauseIcon() {
- return (
-
- );
-}
-
-export function PlayIcon() {
- return (
-
- );
-}
-export function Heart({liked, animate}) {
- return (
- <>
-
-
-
-
- );
-}
-
-export function IconSearch(props) {
- return (
-
- );
-}
-```
-
-```js src/Layout.js active
-import {unstable_ViewTransition as ViewTransition} from 'react'; import { useIsNavPending } from "./router";
-
-export default function Page({ heading, children }) {
- const isPending = useIsNavPending();
- return (
-
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js hidden
-import { useState, unstable_ViewTransition as ViewTransition } from "react";
-import LikeButton from "./LikeButton";
-import { useRouter } from "./router";
-import { PauseIcon, PlayIcon } from "./Icons";
-import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js hidden
-import { useState, unstable_ViewTransition as ViewTransition } from "react";
-import LikeButton from "./LikeButton";
-import { useRouter } from "./router";
-import { PauseIcon, PlayIcon } from "./Icons";
-import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js hidden
-import { useState, unstable_ViewTransition as ViewTransition } from "react";
-import LikeButton from "./LikeButton";
-import { useRouter } from "./router";
-import { PauseIcon, PlayIcon } from "./Icons";
-import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js
-import { useState, unstable_ViewTransition as ViewTransition } from "react"; import LikeButton from "./LikeButton"; import { useRouter } from "./router"; import { PauseIcon, PlayIcon } from "./Icons"; import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- return (
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js hidden
-import { useState, unstable_ViewTransition as ViewTransition } from "react";
-import LikeButton from "./LikeButton";
-import { useRouter } from "./router";
-import { PauseIcon, PlayIcon } from "./Icons";
-import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
- {/* Custom classes based on transition type. */}
-
- {heading}
-
- {isPending && }
-
-
-
-
-
{children}
-
-
- );
-}
-```
-
-```js src/LikeButton.js hidden
-import {useState} from 'react';
-import {Heart} from './Icons';
-
-// A hack since we don't actually have a backend.
-// Unlike local state, this survives videos being filtered.
-const likedVideos = new Set();
-
-export default function LikeButton({video}) {
- const [isLiked, setIsLiked] = useState(() => likedVideos.has(video.id));
- const [animate, setAnimate] = useState(false);
- return (
-
- );
-}
-```
-
-```js src/Videos.js hidden
-import { useState, unstable_ViewTransition as ViewTransition } from "react";
-import LikeButton from "./LikeButton";
-import { useRouter } from "./router";
-import { PauseIcon, PlayIcon } from "./Icons";
-import { startTransition } from "react";
-
-export function Thumbnail({ video, children }) {
- // Add a name to animate with a shared element transition.
- // This uses the default animation, no additional css needed.
- return (
-
-
-
-There are a few known issues we plan to address such as performance, and the scheduler track not always "connecting" work across Suspended trees, so it's not quite ready to try. We're also still collecting feedback from early adopters to improve the design and usability of the tracks.
-
-Once we solve those issues, we'll publish experimental docs and share that it's ready to try.
-
----
-
-## Compiler IDE Extension {/*compiler-ide-extension*/}
-
-Earlier this week [we shared](/blog/2025/04/21/react-compiler-rc) the React Compiler release candidate, and we're working towards shipping the first SemVer stable version of the compiler in the coming months.
-
-We've also begun exploring ways to use the React Compiler to provide information that can improve understanding and debugging your code. One idea we've started exploring is a new experimental LSP-based React IDE extension powered by React Compiler, similar to the extension used in [Lauren Tan's React Conf talk](https://conf2024.react.dev/talks/5).
-
-Our idea is that we can use the compiler's static analysis to provide more information, suggestions, and optimization opportunities directly in your IDE. For example, we can provide diagnostics for code breaking the Rules of React, hovers to show if components and hooks were optimized by the compiler, or a CodeLens to see [automatically inserted Effect dependencies](/#automatic-effect-dependencies).
-
-The IDE extension is still an early exploration, but we'll share our progress in future updates.
-
----
-
-## Automatic Effect Dependencies {/*automatic-effect-dependencies*/}
-
-When we released hooks, we had three motivations:
-
-- **Sharing code between components**: hooks replaced patterns like render props and higher-order components to allow you to reuse stateful logic without changing your component hierarchy.
-- **Think in terms of function, not lifecycles**: hooks let you split one component into smaller functions based on what pieces are related (such as setting up a subscription or fetching data), rather than forcing a split based on lifecycle methods.
-- **Support ahead-of-time compilation**: hooks were designed to support ahead-of-time compilation with less pitfalls causing unintention de-optimizations caused by lifecycle methods, and limitation of classes.
-
-Since their release, hooks have been successful at *sharing code between components*. Hooks are now the favored way to share logic between components, and there are less use cases for render props and higher order components. Hooks have also been successful at supporting features like Fast Refresh that were not possible with class components.
-
-### Effects can be hard {/*effects-can-be-hard*/}
-
-Unfortunately, some hooks are still hard to think in terms of function instead of lifecycles. Effects specifically are still hard to understand and is the most common pain point we hear from developers. Last year, we spent a significant amount of time researching how effects were used, and how those use cases could be simplified and easier to understand.
-
-We found that often, the confusion is from using an Effect when you don't need to. The [You Probably Don't Need an Effect guide](/TODO), covers many cases for when Effects are not the right solution. However, even when an Effect is the right fit for a problem, Effects can still be harder to understand than class component lifecyles.
-
-We believe one of the reasons for confusion is the dependency array, which allows developers to think of effects from the _components_ perspective (like a lifecycle), instead of the _effects_ point of view (what the effect does).
-
-Let's look at an example [from the docs](/learn/lifecycle-of-reactive-effects#thinking-from-the-effects-perspective):
-
-```js
-useEffect(() => {
- // Your Effect connected to the room specified with roomId...
- const connection = createConnection(serverUrl, roomId);
- connection.connect();
- return () => {
- // ...until it disconnected
- connection.disconnect();
- };
-}, [roomId]);
-```
-
-Many users would read this code as "on mount, connect to the roomId. whenever `roomId` changes, disconnect to the old room and re-create the connection". However, this is thinking from the component's lifecycle perspective, which means you will need to think of every component lifecycle state to write the effect correctly. This can be difficult, so it's understandble that Effects seem harder than class lifecycles when using component perspective.
-
-### Effects without dependencies {/*effects-without-dependencies*/}
-
-Instaed, it's better to think from the Effect's perspective. The effect doesn't know about about the component lifecycles. It only describes how to start synchronization and how to stop it. When users think of Effects in this way, their Effects tend to be easier to write, and more resilient to being started and stopped as many times as it’s needed.
-
-We spent some time researching why Effects are thought of from the component perspective, and we think one of the resons is the dependency array. Since you have to write it, it's right there and in your face reminding you of what you're "reacting" to and baiting you into the mental model of 'do this when these values change'.
-
-When we released hooks, we knew we could make them easier to use with ahead-of-time compilation. With the React Compiler, you're now able to avoid writing `useCallback` and `useMemo` yourself in most cases. For Effects, the compiler can insert the dependencies for you:
-
-```js
-useEffect(() => {
- const connection = createConnection(serverUrl, roomId);
- connection.connect();
- return () => {
- connection.disconnect();
- };
-}); // compiler inserted dependencies.
-```
-
-With this code, the React Compiler can infer the dependencies for you and insert them automatically so you don't need to see or write them. With features like the IDE exension and `useEffectEvent`, we can provide a CodeLens to show you what the Compiler inserted for times you need to debug, or to optimize by removing a dependency. This helps reinforce the correct mental model for writing Effects, which can run at any time to synchronize your component or hook's state with something else
-
-Our hope is that automatically inserting dependencies is not only easier to write, but that it also makes them easier to understand by forcing you to think in terms of what the effect does, and not in component lifecycles.
-
----
-
-## Fragment Refs {/*fragment-refs*/}
-
-Many DOM APIs like those for event management, positioning, and focus are difficult to compose when writing with React. This often leads developers to reach for Effects, managing multiple Refs, or APIs like `findDOMNode` (removed in React 19).
-
-We are exploring adding refs to Fragments that would point to a group of DOM elements, rather than just a single element. Our hope is that this will simplify managing multiple children and make it easier to write composable React code when calling DOM APIs.
-
-Fragment refs are still being researched. We'll share more when we're closer to having the final API finished.
-
----
-
-## Gesture Animations {/*gesture-animations*/}
-
-We're also researching ways to enhance View Transitions to support gesture animations such as swiping to open a menu, or scroll through a photo carousel.
-
-Gestures present new challenges for a few reasons:
-
-- **Gestures are continuous**: as you swipe the animation is tied to your finger placement time, rather than triggering and running to completion.
-- **Gestures don't complete**: when you release your finger gesture animations can run to completion, or revert to their original state (like when you only partially open a menu) depending on how far you go.
-- **Gestures invert old and new**: while you're animating, you want the page you are animating from to stay "alive" and interactive. This inverts the browser View Transition model where the "old" state is a snapshot and the "new" state is the live DOM.
-
-We believe we’ve found an approach that works well and may introduce a new API for triggering gesture transitions. For now, we're focused on shipping ``, and will revisit gestures afterward.
-
----
-
-## Concurrent stores {/*concurrent-stores*/}
-
-When we released React 18 with concurrent rendering, we also released `useSyncExternalStore` so external store libraries that did not use React state or context could [support concurrent rendering](https://github.com/reactwg/react-18/discussions/70) by forcing a sync render when the store is updated.
-
-Using `useSyncExternalStore` comes at a cost though, since it forces bail out from concurrent features like transitions, and forces existing content to show Suspense fallbacks.
-
-Now that React 19 has shipped, we're re-visiting this problem space to create a primitive to fully support concurrent external stores with the `use` API:
-
-```js
-const value = use(store);
-```
-
-Our goal is to allow external state to be read during render without tearing, and to work seamlessly with all of the concurrent features React offers.
-
-This research is still early. We'll share more, and what the new APIs will look like, when we're further along.
-
----
-
-_TODO: Thanks to [Dan Abramov](https://bsky.app/profile/danabra.mov), [Lauren Tan](https://bsky.app/profile/no.lol), [Jack Pope](https://jackpope.me), [Jason Bonta](https://threads.net/someextent), [Jordan Brown](https://github.com/jbrown215), [Jordan Eldredge](https://bsky.app/profile/capt.dev), and [Mofei Zhang](https://threads.net/z_mofei) for reviewing this post.
- 
- 
- 
-