react changelog

Here's a rundown of the latest updates and improvements. Get ready to dive into some exciting new features and essential fixes! 🚀

New Features:

• View Transition Refs (#32038): We've introduced ViewTransitionRef objects, giving developers more control over animations. These refs allow you to programmatically manage animations for view transitions, offering an alternative to CSS-based animations. While it doesn't yet support SSR, this feature is a big step toward more dynamic transitions. 🎥

• View Transition Events (#32041): Say hello to five new events for <ViewTransition>. These events (onEnter, onExit, onLayout, onShare, onUpdate) provide hooks for specific moments in the transition lifecycle, allowing for more precise animation control. Each event receives a ViewTransitionInstance, so you can animate without needing a ref. 🎉

• View Transition Class Names (#32050): Now you can apply specific class names based on the transition event kind. This update adds five props (enter, exit, layout, share, update) to <ViewTransition>, making it easier to tailor animations to your needs. Plus, the "none" value lets you opt-out of certain transitions for finer control. 🎨

• ESLint Plugin React Hooks Enhancement (#30774): We've added support for flat configuration in eslint-plugin-react-hooks, making it easier to integrate with ESLint 9.0.0 and above. This update simplifies configuration and maintains compatibility with older ESLint versions. 🔧

• Automatic PR Labeling (#32100): Introducing a MAINTAINERS file to document core team members and automatically label PRs from them, improving workflow and transparency. 🏷️

Improvements:

• Restore useMemoCache (#32067): We've enhanced caching capabilities by restoring useMemoCache in renderers that support Client APIs, boosting performance and efficiency. 🛠️

• Reduce Nullable Hooks Risk (#32068): Enhancements to the Dispatcher ensure certain hooks are non-nullable, reducing potential runtime errors and improving type safety. 🔒

• Console Forks Removal Flag (#32058): A new feature flag allows for the removal of console-related warnings and errors, enhancing the developer experience by reducing noise during development. 📉

Bug Fixes:

• DevTools Profiling Sessions (#32066): Fixed an issue causing DevTools to freeze during consecutive profiling sessions by clearing existing profiling data before starting a new session. No more infinite loops! 🔄

• Compiler Edge Case (#32055): Resolved an edge case in the React compiler related to object methods, ensuring smoother compilation with compilationMode: infer. 🛠️

• DevTools useResourceEffect Support (#32088): Added missing support for the useResourceEffect hook in React DevTools, preventing errors and improving stability. 📈

Chores:

• Remove batchedUpdate Usage (#32074): Refactored DevTools to eliminate the now no-op batchedUpdates function, streamlining code for concurrent mode. 🧹

Stay tuned for more updates, and enjoy these new capabilities and improvements! 🌟

Hey there, React fans! We've been busy making some exciting updates and improvements to the React framework. Check out the latest changes that are sure to enhance your development experience and bring some extra pizzazz to your projects! 🚀✨

• New feature: The React Fiber architecture now supports View Transitions v2, with a focus on using View Transition Classes and Types. This ensures that animations are only triggered if the browser supports the necessary features, providing a more consistent user experience across different platforms. 🌟

• New feature: Navigation support has been added to the View Transition fixture, utilizing both history.pushState/popstate and the Navigation API. This enhances the synchronization of navigation transitions and scroll restoration, improving the overall user experience. 🧭

• New feature: Introducing the <ViewTransition> component! This nifty addition allows you to animate changes between UI states during asynchronous updates, making your apps look smooth and delightful. 🎨

• New feature: You can now style your View Transitions using the className prop on the <ViewTransition> component, enabling reusable and composable styling. CSS Modules are fully compatible, making it easy to maintain unique namespaces for your transition styles. 🎨

• New feature: A new GitHub Actions workflow has been introduced to send notifications to Discord when a pull request is labeled with "React Core Team," ensuring important updates don't go unnoticed. 🔔

• Improvement: The React DOM testing framework has been enhanced with more assert helpers, improving the consistency and effectiveness of testing practices across various components. 🛠️

• Improvement: The RefStatic and LayoutStatic flags in the React reconciler have been unified, simplifying the handling of offscreen content and enhancing the efficiency of the rendering process. ⚡

• Chore: The display of component names during tracing in React DevTools is now enabled by default, making debugging more informative and straightforward. 🕵️‍♂️

• New feature: The ViewTransitionComponent has been added to React DevTools, ensuring it is recognized and can be visually distinguished within the development tools. 🔍

• Bugfix: Fixed a scrolling issue in the React DevTools tree view, ensuring scrolling to an item only occurs when the components panel is visible, improving the user experience. 🐛

• Bugfix: Addressed a warning issue related to empty string href attributes during hydration, streamlining attribute handling for various HTML elements. 🔧

• Bugfix: The react-compiler-runtime package now consistently outputs in CommonJS format, enhancing compatibility and simplifying module handling for developers. 📦

Stay tuned for more updates as we continue to improve and expand React's capabilities. Happy coding! 🎉

Here's the latest scoop on the updates and improvements made to our codebase! We've been busy enhancing performance, fixing bugs, and streamlining processes to make everything run smoother and faster. Let's dive into the details of the most significant changes:

New Feature: Profiler Mode for Fixtures 🎉

We've simplified the component-level profiling process by adding a Profiler mode to fixtures, no longer requiring React DevTools installation. This change resolves previous inconsistencies and lets developers easily access performance insights by wrapping main application components within a Profiler component in the hydrateRoot calls. Say goodbye to confusion and hello to a streamlined profiling setup!

Improvement: Parcel Flight Client Enhancement 🚀

The Parcel Flight client now includes the prepareDestinationForModule function, ensuring components dynamically imported during rendering are preloaded effectively. The <Resources> component now inserts only <link> elements for stylesheets, leaving scripts to React. This change helps prevent Flash of Unstyled Content (FOUC) and opens up discussions for future improvements in resource management.

Improvement: Compiler Bundler Switch to esbuild 🛠️

We've switched the compiler's bundler from Rollup to esbuild, drastically reducing build times from 75 seconds to under 10 seconds! This change optimizes the build process for Node.js environments, making our development workflow more efficient. Out with the old, in with the new—esbuild is here to stay!

New Feature: Yield Every Other Frame for Transition/Retry Work 🎨

To improve performance during transitions and retries, we've introduced a new scheduling mechanism that yields every 25ms. This change helps prevent animations from hogging CPU time, ensuring smoother transitions and a more responsive user interface. While currently disabled by default, this feature represents a strategic move towards optimizing React's rendering performance.

Bugfix: DevTools Compiler Integration Test 🐛

We've fixed a pesky bug in the DevTools integration test related to version handling, specifically addressing a TypeError: Invalid Version: 19. The updated version condition in our script now correctly processes the version range, allowing the integration tests to run smoothly without any version validation hiccups.

Chore: ReactDOMFloat Test Refactor 🧹

We've split the ReactDOMFloat testing into its own pull request to better manage its complexity. This refactor enhances the clarity and maintainability of our tests, allowing for more focused reviews and discussions. It's all about keeping things organized and efficient!

These updates reflect our ongoing commitment to improving performance, enhancing user experience, and maintaining high-quality code standards. Stay tuned for more exciting developments!

Hey there, code wizards! We've been busy brewing up some magical improvements and fixes in the React compiler. Here's what's new and improved in our latest update! 🚀✨

• New Feature: Magical Fire Imports 🔥
  We've added an experimental feature that automatically sprinkles in import { useFire } from 'react' whenever you use the mystical "fire" syntax. This is still in the cauldron, bubbling away, and might not make it to the final potion, but it’s a step towards making your coding spells more powerful!

• Improvement: Cast Those Types Like a Pro! 🪄
  The compiler now gracefully handles type cast expressions with references, eliminating those pesky false positives when a ref-accessing function is placed inside a type-cast array. Your type-casting magic just got a whole lot smoother!

• Improvement: Keep Your Fires Inside! 🔥🏠
  We've tightened the rules to ensure that all fire calls are safely tucked inside effect lambdas. This prevents any rogue fires from causing chaos in your code. Plus, we've corrected the import path to keep everything neat and tidy.

• Improvement: Rewriting the Rules of Fire 🔄
  When using fire in effect dependency arrays, we now ensure they’re literal arrays. This rewrite ensures your spells are precise and error-free, giving you clear feedback if things go astray.

• Bugfix: Fixing the Fire Snap 🔧🔥
  We’ve fixed a broken snapshot related to the fire function, ensuring your useEffect hooks are structured correctly and work like a charm. No more compilation errors to worry about!

• Bugfix: Yielding No More 🚫🛠️
  The enableYieldingBeforePassive feature has been turned off in internal test renderers, due to some hiccups on the React Native side. This is a temporary fix, ensuring smooth sailing while we iron out the kinks.

• Chore: Cleaning Up the Unused Spells 🧹
  We’ve removed the unused toWarnDev function from the testing fixtures. It was just gathering dust, so we’ve tidied up to keep our codebase sparkling clean.

That’s it for now, folks! Keep coding, keep creating, and may your React adventures be nothing short of magical! 🧙‍♂️✨

Hey there, React fans! 🎉 We've got some exciting updates that are sure to make your hydration processes smoother than ever. Let's dive into what's new:

• New Feature: Hydration Lanes in Action 🚀
  We've revamped how hydration work is scheduled by using Hydration Lanes instead of raw update lanes. This means no more random hydration mixing with other updates! Now, when you initiate root hydration or use unstable_scheduleHydration, it's all handled through the right lanes. This change prevents unnecessary client rendering during hydration, ensuring a smoother and more efficient process.

• Bugfix: No More Unwanted Client Rendering 🐛
  Updating a root while it's still hydrating used to cause some hiccups, like triggering client rendering when it wasn't needed. With our new approach, updates apply after hydration, sidestepping any potential mix-ups and keeping things running like a well-oiled machine.

• Performance Boost: Streamlined Hydration and Updates ⚡
  We've tackled potential performance issues by ensuring that unstable_scheduleHydration doesn't get tangled with updates that might force a rewind. Now, hydration starts cleanly without unnecessary updates, making your app snappier and more reliable.

• Safety First: Feature Flag Added 🔒
  We've introduced a kill switch, enableHydrationLaneScheduling, for those who love to experiment but want a safety net. It's all about giving you control while keeping things safe, especially since these scenarios are pretty rare.

With these improvements, your React apps are set to hydrate like never before. Happy coding! 🌟

Hey there, code adventurers! We've got some exciting updates and bug squashes in our latest changelog. Dive in to see what's new and improved in the world of React! 🚀

• New feature: Say hello to the react-server-dom-parcel-package! This shiny new package integrates React Server Components (RSC) with the Parcel bundler, making your life easier by combining client and server modules into a single graph. No more separate manifest files, and CSS gets combined automatically! Plus, a special <Resources> component is generated to handle scripts and stylesheets. 🎉

• Improvement: We've enhanced the scheduling of hydration work by using Hydration Lanes. This ensures hydration tasks don't mix with other updates, preventing unnecessary client rendering. A new feature flag, enableHydrationLaneScheduling, lets you experiment with this approach safely. 💧

• Improvement: The enableOwnerStacks feature is now dynamic! This means you can toggle it on or off during development, giving you more control over captureOwnerStack behavior. We've updated tests to reflect this change, ensuring accurate console error messages based on the flag's state. 🔄

• Improvement: Our compiler now supports non-declaration initializations in for...of and for...in loops. This enhancement allows for more complex patterns without hitting error states, making your code more flexible and robust. 🛠️

• Bugfix: Fixed a pesky issue where refs were being dropped when using spread properties in JSX. Now, both the ref and spread properties are combined correctly in the output, ensuring your components work as intended. 🐛

• New feature: The react-server-dom-parcel package is going public! We've removed the "private" attribute, paving the way for broader access and integration into meta-frameworks. 🌐

• Bugfix: We've fixed the canary version strings by reverting the canaryChannelLabel back to 'canary'. This ensures correct version names and tags after the stable release of version 19. 📦

• Chore: Updated version numbers for prerelease channels, including canary and experimental versions. This keeps everything in sync and up-to-date with the latest improvements and fixes. 🔢

That's all for now, folks! Keep coding and stay tuned for more awesome updates. Happy hacking! 💻✨

Welcome to the latest React updates, where we've been busy making things smoother, faster, and just all-around better! 🚀 Let's dive into the highlights:

New feature

• Meta Magic! We've added a shiny new target option, target: 'donotuse_meta_internal', specifically for Meta bundles. This allows for direct imports of useMemoCache from the react package, making life easier for Meta applications by ensuring compatibility and up-to-date React features. 🎉

Improvement

• Suspense No More! We've tackled an issue with Suspense boundaries during server-side rendering (SSR). Now, if the server stream is incomplete, React will schedule client renders for any unfinished Suspense boundaries once the document fully loads. This ensures your app doesn't get stuck in a fallback state. 🛠️

• Default Imports Delight: The React compiler now supports default imports in the autodependency config. This means you can smoothly import functions like import useWrapperEffect from 'useWrapperEffect', making dependency management a breeze. 🌬️

• Refine those Refs: We've improved the React compiler by skipping .current field accesses in inferred dependency arrays. This change helps avoid incorrect dependency tracking, enhancing the reliability of your effect hooks. 🔧

Bugfix

• Typo Tidy-Up: We've fixed a couple of typos in the CHANGELOG.md, ensuring clarity and professionalism in our documentation. Because every letter counts! 📝

• Back to Basics: A previous update to eslint-plugin-react-compiler has been reverted due to compatibility issues with older Babel versions. This ensures that older codebases can continue to function without hiccups. 🔄

These updates reflect our ongoing commitment to improving React's performance and developer experience. Keep coding, and enjoy the new features and fixes! 🎈

Here's a fun and exciting changelog update for you! 🎉 We've got some cool new features and improvements that are sure to make your coding experience even more delightful. Let's dive into the latest changes:

• New feature: Infer deps configuration 🌟
  Introducing a snazzy new way to configure dependency inference for React effect hooks! This experimental feature lets you specify which functions to analyze for dependencies based on their module and required arguments. Whether it's useEffect from React or a custom useExperimentalEffect hook, your dependencies are now smartly appended to the argument list. Get ready for a smoother coding experience! 🚀

• Improvement: Conditional export of useResourceEffect 🔄
  We've made it easier to detect the presence of useResourceEffect by conditionally exporting it based on a feature flag. This update brings clarity and flexibility, allowing you to use this hook only when the enableUseResourceEffectHook flag is enabled. Say goodbye to confusion and hello to streamlined feature management! 🎯

• Improvement: Mark all lanes in order on every new render 🛤️
  No more missing out on performance lanes! We've ensured that all four lanes are displayed in the correct priority order, even if they're not actively used. This update helps you visualize all your options and keep track of performance metrics accurately. All aboard the performance train! 🚂

• New feature: First cut at dep inference 🧩
  We're exploring the future of effect dependency management with an initial prototype that automatically infers dependencies for useEffect calls lacking a dependency array. Although it's still in the research phase, this feature lays the groundwork for a more automated approach to managing effect dependencies. Stay tuned for more exciting developments! 🔍

• Improvement: Prune unused array destructure items during DCE ✂️
  Our Dead Code Elimination process just got an upgrade! We can now prune unused items from array patterns more effectively, replacing them with "holes" when necessary. This enhancement is especially handy for identifying unused useState destructured items, helping you maintain best practices effortlessly. Clean code, happy code! 🧹

• New feature: Add moveBefore Experiment 🔄
  Say goodbye to state loss when reordering stateful nodes! The moveBefore() function is here to preserve state during node reordering. Although still experimental, this feature promises to solve a long-standing issue in React. Keep an eye out for this game-changer! 👀

• Chore: Replace deprecated dependency in eslint-plugin-react-compiler 🛠️
  We've swapped out a deprecated Babel plugin dependency to keep things fresh and up-to-date. By replacing @babel/plugin-proposal-private-methods with @babel/plugin-transform-private-methods, we're ensuring compatibility with the latest Babel features. Your codebase is now healthier and happier! 🌱

That's all for now, folks! Keep coding and enjoy the new features and improvements. Until next time! 👋

Hey there, code enthusiasts! We've got a fresh batch of updates to share with you, packed with new features, bug fixes, and improvements that are sure to make your coding experience even more delightful. Let's dive right in! 🚀

• New Feature: Separate SuspendedOnAction Flag
  Introducing a new SuspenseActionException to help you track suspensions caused by actions vs. data! This nifty update aims to improve how React handles promises, making your debugging life a tad easier. Just a heads up, though – it's a bit complex and might lead to extra renders. 🤔

• New Feature: Scaffold Initial Types
  Say hello to useResourceEffect, a brand new dispatcher type that's setting the stage for future enhancements in React's hooks system. While it's still a work in progress, it's a promising addition to the framework. 🎉

• New Feature: Enable UseResourceEffectHook Flag
  We've added a shiny new feature flag, enableUseResourceEffectHook, to help manage resources more efficiently. It's experimental for now, but keep an eye out for its potential in boosting React's performance! 🌟

• New Feature: Rename Effect Type
  Introducing a new Effect type, currently an alias for SimpleEffect, but it's all part of a grand plan to enhance React's effect management system. Stay tuned for more exciting updates! 🔄

• Bugfix: Reactive Ref Handling
  We've squashed a bug that was causing ref.current to misbehave in the reactivity department. Now, your refs will be as reactive as ever, ensuring your components work seamlessly! 🐛🔨

• Improvement: Enable on RTR FB Builds
  The enableUseResourceEffectHook flag is now live on React Native builds for Facebook, bringing new resource management capabilities to the table. 🎛️

• Bugfix: Type Inference + Control Flow
  Addressing a type inference bug, we've added a reproduction case to highlight the issue. Plus, we've tweaked some functions to improve consistency with Flow and TypeScript. 🔍

• Improvement: Support Ref as Prop in JSX
  enableRefAsProp is now fully supported in the JSX transform, ensuring your refs are handled consistently across the board. 📦

• New Feature: Basic Implementation of useResourceEffect
  An experimental hook, useResourceEffect, is here for early testing. It's still in its infancy, so don't rely on it just yet, but it's an exciting glimpse into the future of React! 🔬

• Bugfix: Dependency Comparison in useResourceEffect
  We've fixed a pesky bug in useResourceEffect that was causing incorrect dependency comparisons. The fix ensures your effects are handled correctly, even when mixed with other types. 🔧

That's all for now, folks! Keep coding, keep experimenting, and stay tuned for more awesome updates! 🎉👩‍💻👨‍💻

Welcome to the latest updates in our codebase! We've been busy squashing bugs, adding some cool new features, and making improvements that are sure to enhance your experience. Here's a rundown of what's been happening:

Bugfix 🐛

• Fix Overlapping "message" Bug in Performance Track (#31528): We've tackled a pesky issue where overlapping events were causing chaos in React's performance tracking. Now, the end time of the last render is stored to prevent any mishaps, ensuring smoother performance tracking.
• [compiler] Repro for reactive ref.current accesses (#31519): A bug in handling ref.current dependencies has been fixed. We've added a test fixture to make sure those reactive dependencies are tracked accurately, so your components behave just as they should.
• [compiler] Repro for mutable range edge case (#31479): An edge case involving mutable ranges and aliasing in function expressions has been addressed. Test fixtures now ensure our compiler handles these scenarios like a pro.

New Features ✨

• Export __COMPILER_RUNTIME in stable (#31540): The compiler is now part of stable releases like React 19 RC, making it more accessible for developers who want to harness its power.
• Turn on enableSiblingPrerendering in canary (#31541): We've flipped the switch on the enableSiblingPrerendering feature flag, paving the way for exciting new capabilities in the upcoming release candidate.
• [Flight] Add initial readme to react-server package (#31464): A shiny new README for the react-server package is here! It covers the prerender API for Flight, giving you a head start on implementing React Server Components.

Improvements 🌟

• Only log component level profiling for components that actually performed work (#31522): We've streamlined component-level profiling by focusing on components that truly impact performance, reducing noise and making logs more actionable.
• Make prerendering always non-blocking with fix (#31452): Prerendering is now non-blocking, eliminating issues with infinite render loops and enhancing stability.
• Format event with "warning" yellow and prefix with "Event: " (#31536): Event logging just got a makeover with a "warning" yellow color and a consistent naming format, making it easier to track events in the rendering process.

Chore 🧹

• (chore): copy fix in precedence error (#31524): We've corrected a typo in an error message related to <style> tag usage, ensuring clarity in error reporting.

That's all for now! We hope these updates make your development journey smoother and more enjoyable. Keep coding and stay awesome! 🚀

Welcome to the latest round of updates! We've been busy bees, buzzing around making improvements, squashing bugs, and adding cool new features to make your experience even better. Here's what's new:

New Features

• Flight Prerendering with enableHalt: 🚀 We've introduced the enableHalt feature for flight prerenders, allowing aborts to be treated as indefinitely stalled rather than errors. This makes the system more robust and user-friendly by pausing serialization for async data types when accessed by the client.
• Dynamic Module Type Resolution: 🔄 A new environment configuration option lets you resolve imported module types on the fly, making the compiler more flexible and efficient.
• DevTools Owner Path Identification: 🕵️‍♂️ Now you can find Server Component owners by traversing the parent path, improving DevTools' functionality.
• Function Return Type Inference: 🧠 The compiler now infers return types for function expressions, enhancing type management and error handling.
• Ref-in-Render Fixture: 🧩 We've added a fixture to highlight issues with refs in render when using useCallback, improving documentation and testing.

Improvements

• Ref Access Flexibility: 🔧 Functions containing refs can now be returned, offering more flexibility, especially in hooks.
• Compiler Return Identifier: 🏷️ We've added a returnIdentifier to function expressions for better type information management.
• Ref Mutability Handling: 🔒 Refs and their .current values are now excluded from having mutable ranges, preserving memoization integrity.

Bugfixes

• Rendering Aborts and Throws: 🛠️ Fixed an issue where errors thrown after aborting a render were mishandled, ensuring proper error tracking and robustness.
• Flight Halted Row Reversion: 🔄 We reverted the halted row feature in Flight, simplifying promise handling.
• Turbopack Unbundled Removal: 🗑️ Removed the unbundled RSC prototype from Turbopack, focusing on integrated server/client experiences.

Chore

• CI Configuration Cleanup: 🧹 Removed the CI_MAX_WORKERS option from Flow configurations as part of our migration to GitHub Actions.

That's all for now, folks! Keep exploring, keep building, and stay tuned for more exciting updates coming your way. 🎉

Hey there, fellow React enthusiasts! We've been busy bees 🐝 making some exciting updates and improvements to our beloved React ecosystem. Here's a roundup of the latest and greatest changes we've rolled out. Dive in and explore what's new and improved!

• New Feature: Server Component Support in DevTools
  We've added VirtualInstances to the React DevTools tree, making it easier for you to visualize and manage Server Components. Now, a single Server Component instance can appear as one instance, even if it's a parent to multiple children. This means a cleaner, more efficient tree structure for you to work with. However, keep an eye out for some quirky behavior during updates, especially with list reorders. We're working on making it even smoother!

• New Feature: Macro Methods in the Compiler
  Say hello to macros as methods! We've expanded the React compiler to support macros invoked as methods, not just function calls or JSX. This means more flexibility in defining macros, like myMacro.*.foo.bar. The compiler now builds a map of partially-satisfied macro patterns, recognizing when a macro pattern is fully satisfied. This enhancement is all about giving you more power and flexibility in your coding adventures.

• New Feature: Experimental renderToHTML Function
  We've rolled out the experimental_renderToHTML function in the react-markup package. It's perfect for generating HTML markup in contexts like email templates that use Server Components. With a nod to its experimental status, this function is all about pushing the boundaries and seeing what's possible.

• New Feature: Prerendering in Flight
  Introducing prerendering in the Flight framework, similar to Fizz. Instead of an immediate stream result, you get a promise that resolves to the stream once prerendering is complete. This enhancement improves error handling and streamlines the prerendering process, making Flight even more robust and reliable.

• New Feature: Increment/Decrement Support in Compiler
  We've added support for increment (++) and decrement (--) operations on member expressions in the React compiler. This means expressions like a.x++ are now handled seamlessly, preserving the semantics of these operations. More power to you when managing member expression updates!

• Improvement: Promotion of Temporaries in Compiler
  We've improved how the React compiler handles temporaries to prevent unintended code reordering over side-effectful operations. This ensures that your code executes in the intended order, preventing unexpected behaviors and keeping everything running smoothly.

• Bugfix: Unhandled Rejection in Flight
  We've squashed a bug that caused unhandled promise rejection errors in Flight when aborting a synchronous operation. Now, errors after an abort are properly handled, making the error handling in React's server components more robust.

• New Feature: useTransition Support in Compiler
  The useTransition hook is now supported in the Forget compiler, marking the startTransition function as stable. This enhancement is all about managing concurrent state updates more effectively, giving you more control and stability in your React applications.

• Improvement: Server Component Key in DevTools
  We've enhanced DevTools to display the key of a Server Component, aiding the reconciliation process and preserving instance equality during reorders. This improvement helps you better understand component hierarchies and relationships, even if keys can be a bit confusing with filtering.

• Bugfix: Path Fix in CI Workflow
  We've corrected an incorrect path in the compiler_typescript.yml GitHub Actions workflow. This fix ensures that the workflow triggers correctly when changes are made, keeping our CI process running smoothly.

• Bugfix: unstable_useContextWithBailout Dispatcher Assignment
  We've fixed an issue with the unstable_useContextWithBailout dispatcher assignment, ensuring unique assignments across different dispatcher instances. This fix is all about maintaining context integrity and preventing potential issues from shared references.

We hope these updates make your React journey even more enjoyable and efficient! Stay tuned for more exciting developments, and happy coding! 🎉

### Hey there, fellow devs! 🎉

We've got a bunch of exciting updates, improvements, and bug fixes to share with you. Buckle up and let's dive into the latest changes!

#### New Features

- **DevTools Fiber Backend Refactor**: We've started refactoring the DevTools Fiber backend to build a filtered shadow tree by listening to each commit from Fiber and traversing the tree. This new approach enhances resilience to different Fiber implementations and improves the accuracy of shadow trees. 🌳
  
- **Highlighting HostSingletons, Hoistables, and Resources**: The DevTools now support highlighting and inspecting new Float types, including HostSingletons, Hoistables, and Resources. This makes it easier to trace the origins of resources and improves the debugging experience. 🔍

- **Compiler's DeclarationId**: Added `Identifier.declarationId` and a simulated opaque type `DeclarationId` to uniquely identify variables in the original source code. This helps maintain SSA form throughout compilation while distinguishing between SSA and non-SSA versions. 🆔

- **Global Mutation Effects in Hooks**: The compiler now allows global mutation effects in arguments passed to hooks and their return values, enhancing flexibility while maintaining React's side effect principles. 🌐

- **LowerContextAccess Pass**: Introduced a new compiler pass for internal profiling to optimize context access by synthesizing selector functions from context accesses. This enhances performance by reducing unnecessary context retrieval. ⚙️

- **Rewrite useContext Callee**: Modified the compiler to allow specifying a custom callee for `useContext`, enabling internal experimentation with context access for potential performance improvements. 🧪

- **Nightly and Manual Compiler Releases**: Added workflows for publishing compiler packages on the same schedule as React packages, including nightly builds and manual releases. This ensures consistent and streamlined package management. 🌙

- **Publishing Packages to npm**: Updated workflow to actually publish packages to npm, automating the release process and enhancing efficiency. 📦

#### Improvements

- **DevTools Global for Native**: Introduced `__IS_NATIVE__` global for differentiating backend implementation for `react-devtools-core` in React Native. This improves error reporting and tailors the experience for React Native developers. 📱

#### Bugfixes

- **ValidatePreserveMemo x useRef Bug**: Fixed an issue where the `useRef` hook wasn't preserving references correctly within memoized components, ensuring reliable state management. 🔧

- **Fix Incorrect Tags for Compiler Releases**: Corrected the tagging process for compiler releases, ensuring that the correct tags are pushed during the release process. 🏷️

- **Shared Lint Cache Key**: Resolved an issue with the caching mechanism in the shared linting workflow, ensuring jobs can successfully hit the cache by using consistent hash values. 🗝️

That's all for now, folks! Happy coding! 🚀

Welcome to the latest batch of updates, where we've sprinkled in some magic to make your development experience even more delightful! 🎉 Here's what's new:

New Features

• Internal Performance Profiling with Context Bailout: Introducing unstable_useContextWithBailout! This temporary hook lets you provide a comparison function along with a Context to determine if Context propagation and rendering should bail out earlier. It's all about making those updates snappier! 🚀

• DevTools Gets Smarter: Say hello to DevToolsInstance! This new feature helps track Server Components more effectively by distinguishing between FiberInstance (Client Components) and VirtualInstance (Server Components). Expect a smoother, more intuitive DevTools experience. 🛠️

• Flight Logs with Owner Stacks: When replaying logs on the client, owner stacks are now enabled. This makes debugging easier by providing more context, even outside specific rendered components. 🛫

• GH Actions for Prereleases: We've added new workflows for publishing prereleases using GitHub Actions. This ensures a seamless transition from CircleCI, keeping everything running smoothly. 🔧

Improvements

• Abort Fizz Renders Mid-flight: You can now abort Fizz renders during their execution, preventing incomplete render states and ensuring task counting stays consistent. 🛑

• Snappy Element Inspection in DevTools: We've ditched timers for batching bridge traffic, making Element Inspection feel much more responsive. No more sluggish interactions! ⚡

• Resolved Props Handling: Resolved outlined props are now assigned to both the element tuple and the parsed element object, ensuring integrity and performance during rendering. 🧩

Bugfixes

• Global Updates in Callbacks: Fixed an issue where updates to global variables within callbacks were not retained. Your global state should now behave as expected during component renders. 🌍

• Nested Scopes in Promoted Temporaries: Ensuring that nested scopes within pruned ones are correctly visited and promoted, making the compiler more robust. 🕵️‍♂️

• fbt Plural and Macro Bugs: Added test fixtures to address pluralization and macro property bugs in the fbt framework. This helps ensure your translations are accurate and reliable. 🌐

Chores

• Farewell CircleCI: We've completed our migration to GitHub Actions and bid adieu to .circleci. Streamlined workflows ahead! 👋

That's a wrap on the latest updates! Dive in and enjoy the enhanced performance, smarter DevTools, and more reliable rendering. Happy coding! 😄

Changelog

Hey there, fellow coders! Here's what's new, fixed, and improved in our latest update. 🚀

New Features

• Owner Stacks in DevTools: We've introduced "owner stacks" to the React DevTools. When enableOwnerStacks is on, you'll get more detailed component relationships in your debugging info. If it's off, we'll fall back to parent stacks. This makes it easier to see who rendered what! 🎨 (#30417)
• Filter Stack Frames in RSC Server: Customize your stack traces with the new filterStackFrame option. Exclude those pesky node_modules or any other functions you don't want cluttering your error reports. 🧹 (#30447)
• DevTools Regression Workflow: Say hello to our new GitHub Actions workflow for running regression tests on React DevTools. Keeping things smooth and bug-free! 🧪 (#30406)
• Find Source Map URL in ReactNoopFlightClient: Added the findSourceMapURL function to improve source map handling. Better debugging, here we come! 🔍 (#30395)
• Temporary Fork for Runtime Commit Artifacts: Testing new workflows without merging into the main branch just got easier with our temporary fork. Safe and sound! 🛠️ (#30472)

Improvements

• Prefix Owner Stacks in Console Logs: Now, when an error or warning is logged, the current stack is prefixed, making it easier to trace issues. Debugging just got a whole lot simpler! 🐛 (#30427)
• Environment Name in Virtual URL and Source Map: Added environment names to virtual URLs and findSourceMapURL to help locate source maps across multiple server environments. 🌐 (#30452)
• Identifier Mutable Ranges in Compiler: Stopped relying on identifier mutable ranges after constructing scopes. This improves the integrity of the memoization process. 🧠 (#30428)

Bugfixes

• (Arrow)FunctionExpressions Insertion: Fixed an issue where inserting new (Arrow)FunctionExpressions as siblings broke the outlining process. Now, they are correctly inserted as true siblings. 🎯 (#30446)
• Deduped Props in Lazy Elements: Resolved a bug where references to deduped props in lazy elements caused runtime errors. Now, we wait for the lazy element's chunk to resolve. 🛠️ (#30441)
• False Positive in ValidatePreserveManualMemo: Addressed a false positive issue in the ValidatePreserveManualMemo function. More accurate validations coming your way! ✔️ (#30431)

Chore

• Remove CircleCI DevTools Tests: We've migrated our DevTools regression tests to GitHub Actions, so the old CircleCI workflow is now history. 🗑️ (#30468)

That's all for now, folks! Keep coding and stay awesome! 💻✨

Welcome to the latest updates! We've been busy making some exciting changes and improvements. Here's a rundown of what's new and improved:

New Features

• Show Outlined Functions in Logging and Playground: We've enhanced the compiler to show outlined functions in logging and the playground, giving you better visibility and understanding of outlined functions during compilation and reactive function generation. 🎉
• Add process_artifacts_combined Job: A new job has been added to streamline artifact handling in the workflow, making necessary files easily accessible and organized for future use.
• Add run_fixtures_flight_tests Workflow: Automate running Flight tests on fixtures, ensuring consistent execution and archiving results for analysis.
• Add check_error_codes Step: This new step in the GitHub Actions workflow searches for unminified errors, enhancing our automated testing and validation process.
• Add RELEASE_CHANNEL_stable_yarn_test_dom_fixtures Workflow: This workflow checks fixtures DOM in the stable release channel, improving the testing process for stable releases.

Improvements

• Use yargs to Parse Args in download-experimental-build: The script now uses yargs to parse arguments, adding flexibility and improving user experience with a summary message.
• Parallelize yarn build: By parallelizing the build process, we've significantly reduced build times, enhancing efficiency for contributors.
• Fork download-experimental-build.js for GitHub Actions: We've forked the original script to make it easier to review and eventually streamline the process of downloading experimental build artifacts.

Bugfixes

• Fix Sizebot Job Dependency: Addressed an issue with the sizebot job by adding the necessary build_and_lint dependency.
• Update Sizebot Node Modules Caching Strategy: Improved caching strategy to ensure correct modules are cached for the sizebot download job.
• Don't Wrap Non-ASCII FBT Operands in JSXExpressionContainer: Fixed an issue in the compiler to handle non-ASCII FBT operands appropriately, ensuring they are not wrapped unnecessarily.

Chores

• Remove RELEASE_CHANNEL_stable_yarn_test_dom_fixtures from CircleCI: Streamlined the build process by removing unnecessary steps and configurations related to DOM fixture tests.

We hope these updates make your development experience smoother and more efficient. Happy coding! 🚀

Hey there, fellow code wranglers! We've got some nifty updates and fixes coming your way. Check out the highlights below to see what's new and improved. 🚀

New Features

• Add React Native Fork of consoleWithStackDev: We've added a React Native fork of consoleWithStackDev to enhance error handling and warning filtering for React Native. This update helps maintain the interplay between consoleWithStackDev, DevTools, and error dialogs in userspace.
• Support for Serializing Map and Set in Console Logs: Now you can fully serialize Map and Set objects in console logs. This change ensures better debugging and logging of these data structures.
• Feature Flag to Disable Legacy Context for Function Components: Introduced a feature flag to disable legacy context for function components, aiming to streamline the API and prepare for the complete removal of legacy context in the future.
• Support for TSInterfaceDeclaration: Added support for TSInterfaceDeclaration in the compiler, fixing a previously unsupported scenario and ensuring that the transformation process handles such statements correctly.

Bugfixes

• Remove propTypes on Instance Warning: Removed the outdated warning for using propTypes as an instance property in React 19 since propTypes are no longer supported.
• Override getCurrentStack Temporarily While Printing Errors: Updated the Fiber module to override getCurrentStack temporarily for parent stacks while printing errors, ensuring proper error handling and stack trace appending.
• Dedupe Legacy Context Warnings: Ensured that warnings about legacy APIs are only raised once per component, preventing duplicate warnings and improving the clarity of the warning system.

Improvements

• Serialize Rate-Limited Objects in Console Logs: Introduced a marker for rate-limited objects in console logs, which can be emitted as a getter. Increased the object limit in console logs to optimize logging and reduce strain on server and client resources.

That's all for now, folks! Keep coding, keep improving, and stay awesome! 🎉👩‍💻👨‍💻

Welcome to the latest updates! Here’s a rundown of the exciting new features, improvements, and bug fixes:

New Features

• Implemented captureStackTrace and Owner Stacks on Server in Flight: Now, owner stacks are wired up to shared internals, exposing them to captureOwnerStack(). This enhances error logging and debugging by adding owner stacks to errors logged by React. 🎉

• Fizz Debug Info: We’ve added the debugInfo feature to Fizz, allowing you to track Server Component parent stacks and the correct owner stack for lazy components. This makes debugging a breeze! 🕵️‍♂️

• Track Current Debug Task for Error Callbacks in Fizz: Now, when an error is thrown, the current debug task is tracked and used to run onError callbacks within the task's context. This ensures the right async stack is shown during debugging.

Improvements

• Console.createTask During SSR in Fizz: We’ve updated Fizz to run console.createTask during server-side rendering (SSR) when available. This allows you to view component stacks when inspecting the Node.js server using --inspect and Chrome DevTools. 🛠️

• Enhanced Flow Support in Playground: The playground now better supports Flow files by assuming a file is a Flow file when it sees flow anywhere in the file. It parses these files using the Hermes parser and disables TypeScript-specific features of the Monaco editor.

Bugfixes

• Gate LegacyContext Field on disableLegacyContext in Fizz: To conserve fields and avoid unnecessary runtime usage in modern builds, the legacyContext field is now gated on disableLegacyContext.

• Clone Computation Block in Change Detection Mode: In change-detection mode, nodes are now cloned instead of spreading the contents of the computation block twice. This prevents mutations from affecting both places where the block is used, ensuring the overall transform result is not broken.

• Regression Test for Issue #30172: Added an additional test to ensure deduped objects in nested children of blocked models are resolved correctly, preventing regressions.

• No StrictMode Warnings for Production Renderer Builds: StrictMode warnings are now excluded from production renderer builds, as they are intended for development only. This ensures a cleaner display for React applications running in production mode.

That’s all for now! Keep coding and enjoy the new features and improvements! 🚀

Welcome to the latest updates! Here's a rundown of the coolest changes and fixes we've made recently. 🎉

New Features

• Optimize Instruction Reordering: We've turbocharged the compiler with a new instruction reordering strategy! Now, LoadLocal instructions can be reordered more efficiently, and statement blocks have a more optimal reordering process. This helps merge scopes better and reduces memo slots in fixtures.

• New Flags GitHub Action: We've added a new GitHub action for checking yarn flags. This mirrors the existing CircleCI workflow to ensure everything runs smoothly on both platforms.

• New Fizz GitHub Action: Introduced a GitHub action for checking the inlined Fizz runtime. This action ensures that the Fizz runtime is always up to date by mirroring the CircleCI workflow.

• New Package: react-html: Say hello to react-html! This new package includes a renderToMarkup export for rendering HTML that isn't meant to be hydrated. Perfect for emails, RSS feeds, and more.

• New Lint GitHub Action: We've added a new linting action to GitHub. This action runs prettier, eslint, and other checks to keep our codebase in tip-top shape.

Bugfixes

• Validate Against Locals Being Reassigned After Render: Added a validation pass to ensure local variables aren't reassigned by functions called after rendering. This prevents inconsistencies in subsequent renders.

• Warn for Invalid Type in Renderer: Improved error handling for invalid types in the renderer, ensuring the correct stack trace is shown. This is all behind the enableOwnerStacks flag.

• Examples of Invalid Code Reassigning Locals Outside of Render: Added test fixtures to handle cases where local variables are wrongly reassigned outside of the render function.

• Repro for Nested Function Local Reassignment Issue: Introduced a repro case demonstrating issues with nested function local reassignments. This helps pinpoint and address the problem.

• New Error Message for Awaiting the Client Export: Updated the error message for attempting to await client exports, making it clearer and more helpful for avoiding incorrect usage.

Chores

• Remove CircleCI Yarn Flags Job: We've removed the CircleCI yarn_flags job now that it's been migrated to GitHub actions. This helps streamline our CI/CD process.

That's all for now! Keep coding, keep smiling, and stay awesome! 🚀✨

Hey there, fellow React enthusiasts! We've got a fantastic set of updates for you. From new features to important bugfixes, here's what's new and improved in our latest release:

New Features 🎉

• Custom fbt-like Macro Functions in Compiler: The compiler now supports custom fbt-like macro functions! This means you can define and use custom macros similar to fbt, enhancing your application's capabilities. We've updated the Environment configuration schema to include a customMacros field and made necessary changes across various files to support this feature.

• CaptureOwnerStack API in DEV Builds: Introducing captureOwnerStack, a new API available only in development builds. This allows you to implement similar functionality to console.error in user space. Note that this API does not include the current stack from new Error().stack, so you'll need to add that yourself.

• Method-call Version of Macro Functions: The compiler now supports macro.namespace(...) style invocations, adding more flexibility to how you use macros. We've tested various scenarios to ensure everything works smoothly and fixed a few bugs along the way.

• React Native 0.75 Feature Flags: We're prepping for React Native 0.75 with updated feature flags. This ensures a smooth transition to React 19, improving performance and compatibility.

Improvements 🚀

• React DevTools 5.3.0: The latest version of React DevTools brings several enhancements. We've improved console argument formatting, unified console patching, made source maps URL relative, and fixed various inspection and error reporting issues. Plus, component badges are now visible in light mode!

• Treat Ref-like Named Objects as Refs: The compiler now treats objects named ref or ending with Ref, and containing a property named current, as React refs. This update addresses false positives in analysis when using custom hooks.

Bugfixes 🐛

• Non-reactive Dispatch Function from useActionState: The dispatch function from useActionState is now considered non-reactive, ensuring better performance and fewer unnecessary re-renders.

• Dynamic Feature Flag Removal and Revert: We initially removed the dynamic feature flag enableSchedulingProfiler but then reverted this change based on feedback. This ensures the dynamic control of the scheduling profiler remains intact.

• Console Patching Unification: By default, React DevTools will now use ANSI escape symbols for dimming, ensuring consistency across terminals and browser consoles. For Firefox, which doesn't support ANSI escape symbols, we fallback to CSS properties.

Enjoy these updates and happy coding! 🚀