diff --git a/docs/api/createSlice.mdx b/docs/api/createSlice.mdx
index d6b4269764..53b01a1e4a 100644
--- a/docs/api/createSlice.mdx
+++ b/docs/api/createSlice.mdx
@@ -304,16 +304,25 @@ Typing for the `create.asyncThunk` works in the same way as [`createAsyncThunk`]
 
 A type for `state` and/or `dispatch` _cannot_ be provided as part of the `ThunkApiConfig`, as this would cause circular types.
 
-Instead, it is necessary to assert the type when needed.
+Instead, it is necessary to assert the type when needed - `getState() as RootState`. You may also include an explicit return type for the payload function as well, in order to break the circular type inference cycle.
 
 ```ts no-transpile
 create.asyncThunk<Todo, string, { rejectValue: { error: string } }>(
-  async (id, thunkApi) => {
+  // highlight-start
+  // may need to include an explicit return type
+  async (id: string, thunkApi): Promise<Todo> => {
+    // Cast types for `getState` and `dispatch` manually
     const state = thunkApi.getState() as RootState
     const dispatch = thunkApi.dispatch as AppDispatch
-    throw thunkApi.rejectWithValue({
-      error: 'Oh no!',
-    })
+    // highlight-end
+    try {
+      const todo = await fetchTodo()
+      return todo
+    } catch (e) {
+      throw thunkApi.rejectWithValue({
+        error: 'Oh no!',
+      })
+    }
   }
 )
 ```
diff --git a/docs/api/getDefaultMiddleware.mdx b/docs/api/getDefaultMiddleware.mdx
index ef15eca14f..7e51cf618f 100644
--- a/docs/api/getDefaultMiddleware.mdx
+++ b/docs/api/getDefaultMiddleware.mdx
@@ -55,7 +55,7 @@ const store = configureStore({
 // Store has all of the default middleware added, _plus_ the logger middleware
 ```
 
-It is preferable to use the chainable `.concat(...)` and `.prepend(...)` methods of the returned `Tuple` instead of the array spread operator, as the latter can lose valuable type information under some circumstances.
+It is preferable to use the chainable `.concat(...)` and `.prepend(...)` methods of the returned `Tuple` instead of the array spread operator, as the latter can lose valuable TS type information under some circumstances.
 
 ## Included Default Middleware
 
diff --git a/docs/introduction/getting-started.md b/docs/introduction/getting-started.md
index 9bb4cfc038..8085db8f3e 100644
--- a/docs/introduction/getting-started.md
+++ b/docs/introduction/getting-started.md
@@ -34,7 +34,7 @@ you make your Redux code better.
 
 ### Create a React Redux App
 
-The recommended way to start new apps with React and Redux is by using [our official Redux+TS template for Vite](https://github.com/reduxjs/redux-templates), or by creating a new Next.js project using [Next's `with-redux` template](https://github.com/vercel/next.js/tree/canary/examples/with-redux).
+The recommended way to start new apps with React and Redux Toolkit is by using [our official Redux Toolkit + TS template for Vite](https://github.com/reduxjs/redux-templates), or by creating a new Next.js project using [Next's `with-redux` template](https://github.com/vercel/next.js/tree/canary/examples/with-redux).
 
 Both of these already have Redux Toolkit and React-Redux configured appropriately for that build tool, and come with a small example app that demonstrates how to use several of Redux Toolkit's features.
 
@@ -85,8 +85,7 @@ yarn add react-redux
   </TabItem>
 </Tabs>
 
-It is also available as a precompiled UMD package that defines a `window.RTK` global variable.
-The UMD package can be used as a [`<script>` tag](https://unpkg.com/@reduxjs/toolkit/dist/redux-toolkit.umd.js) directly.
+The package includes a precompiled ESM build that can be used as a [`<script type="module">` tag](https://unpkg.com/@reduxjs/toolkit/dist/redux-toolkit.browser.mjs) directly in the browser.
 
 ## What's Included
 
diff --git a/docs/migrations/1.x-to-2.x.md b/docs/migrations/1.x-to-2.x.md
index e98b2f5bc9..d7d4435148 100644
--- a/docs/migrations/1.x-to-2.x.md
+++ b/docs/migrations/1.x-to-2.x.md
@@ -12,15 +12,23 @@ toc_max_heading_level: 4
 
 # Migrating 1.x → 2.x
 
+:::tip What You'll Learn
+
+- What's changed in Redux Toolkit 2.0 and Redux core 5.0, including breaking changes and new features
+
+:::
+
 ## Introduction
 
 Redux Toolkit has been available since 2019, and today it's the standard way to write Redux apps. We've gone 4+ years without any breaking changes. Now, RTK 2.0 gives us a chance to modernize the packaging, clean up deprecated options, and tighten up some edge cases.
 
 Redux Toolkit 2.0 is accompanied by major versions of all the other Redux packages: Redux core 5.0, React-Redux 9.0, Redux Thunk 3.0, and Reselect 5.0.
 
-This page lists known potentially breaking changes in Redux Toolkit 2.0 and Redux core 5.0, as well as new features in Redux Toolkit 2.0. As a reminder, you should not need to actually install or use the core `redux` package directly - RTK wraps that, and re-exports all methods and types.
+This page lists known potentially breaking changes in Redux Toolkit 2.0 and Redux core 5.0, as well as new features in Redux Toolkit 2.0. As a reminder, **you should not need to actually install or use the core `redux` package directly** - RTK wraps that, and re-exports all methods and types.
+
+In practice, **most of the "breaking" changes should not have an actual effect on end users, and we expect that many projects can just update the package versions with very few code changes needed**.
 
-In practice, **most of the "breaking" changes should not have an actual effect on end users**. The changes most likely to need app code updates are:
+The changes most likely to need app code updates are:
 
 - [Object syntax removed for `createReducer` and `createSlice.extraReducers`](#object-syntax-for-createsliceextrareducers-and-createreducer-removed)
 - [`configureStore.middleware` must be a callback](#configurestoremiddleware-must-be-a-callback)
@@ -66,6 +74,20 @@ We've always specifically told our users that [actions and state _must_ be seria
 
 In practice, this was already true 99.99% of the time and shouldn't have any effect on users (especially those using Redux Toolkit and `createSlice`), but there may be some legacy Redux codebases that opted to use Symbols as action types.
 
+#### `createStore` Deprecation
+
+In [Redux 4.2.0, we marked the original `createStore` method as `@deprecated`](https://github.com/reduxjs/redux/releases/tag/v4.2.0). Strictly speaking, **this is _not_ a breaking change**, nor is it new in 5.0, but we're documenting it here for completeness.
+
+**This deprecation is solely a _visual_ indicator that is meant to encourage users to [migrate their apps from legacy Redux patterns to use the modern Redux Toolkit APIs](https://redux.js.org/usage/migrating-to-modern-redux)**. The deprecation results in a visual strikethrough when imported and used, like ~~`createStore`~~, but with _no_ runtime errors or warnings.
+
+**`createStore` will continue to work indefinitely, and will _not_ ever be removed**. But, today we want _all_ Redux users to be using Redux Toolkit for all of their Redux logic.
+
+To fix this, there are three options:
+
+- **[Follow our strong suggestion to switch over to Redux Toolkit and `configureStore`](https://redux.js.org/usage/migrating-to-modern-redux)**
+- Do nothing. It's just a visual strikethrough, and it doesn't affect how your code behaves. Ignore it.
+- Switch to using the `legacy_createStore` API that is now exported, which is the exact same function but with no `@deprecated` tag. The simplest option is to do an aliased import rename, like `import { legacy_createStore as createStore } from 'redux'`
+
 <div class="typescript-only">
 
 #### Typescript rewrite
@@ -78,6 +100,26 @@ Redux core v5 is now built from that TS-converted source code. In theory, this s
 
 Please report any unexpected compatibility issues on [Github](https://github.com/reduxjs/redux/issues)!
 
+#### `AnyAction` deprecated in favour of `UnknownAction`
+
+The Redux TS types have always exported an `AnyAction` type, which is defined to have `{type: string}` and treat any other field as `any`. This makes it easy to write uses like `console.log(action.whatever)`, but unfortunately does not provide any meaningful type safety.
+
+We now export an `UnknownAction` type, which treats all fields other than `action.type` as `unknown`. This encourages users to write type guards that check the action object and assert its _specific_ TS type. Inside of those checks, you can access a field with better type safety.
+
+`UnknownAction` is now the default any place in the Redux source that expects an action object.
+
+`AnyAction` still exists for compatibility, but has been marked as deprecated.
+
+Note that [Redux Toolkit's action creators have a `.match()` method](https://redux-toolkit.js.org/api/createAction#actioncreatormatch) that acts as a useful type guard:
+
+```ts
+if (todoAdded.match(someUnknownAction)) {
+  // action is now typed as a PayloadAction<Todo>
+}
+```
+
+You can also use the new `isAction` util to check if an unknown value is some kind of action object.
+
 #### `Middleware` type changed - Middleware `action` and `next` are typed as `unknown`
 
 Previously, the `next` parameter is typed as the `D` type parameter passed, and `action` is typed as the `Action` extracted from the dispatch type. Neither of these are a safe assumption:
@@ -88,6 +130,8 @@ Previously, the `next` parameter is typed as the `D` type parameter passed, and
 
 We've changed `next` to be `(action: unknown) => unknown` (which is accurate, we have no idea what `next` expects or will return), and changed the `action` parameter to be `unknown` (which as above, is accurate).
 
+In order to safely interact with values or access fields inside of the `action` argument, you must first do a type guard check to narrow the type, such as `isAction(action)` or `someActionCreator.match(action)`.
+
 This new type is incompatible with the v4 `Middleware` type, so if a package's middleware is saying it's incompatible, check which version of Redux it's getting its types from!
 
 #### `PreloadedState` type removed in favour of `Reducer` generic
@@ -119,24 +163,6 @@ This change does include some breaking changes, but overall should not have a hu
 - The overloads for `combineReducers` are removed in favor of a single function definition that takes the `ReducersMapObject` as its generic parameter. Removing the overloads was necessary with these changes, since sometimes it was choosing the wrong overload.
 - Enhancers that explicitly list the generics for the reducer will need to add the third generic.
 
-#### `AnyAction` deprecated in favour of `UnknownAction`
-
-The Redux TS types have always exported an `AnyAction` type, which is defined to have `{type: string}` and treat any other field as `any`. This makes it easy to write uses like `console.log(action.whatever)`, but unfortunately does not provide any meaningful type safety.
-
-We now export an `UnknownAction` type, which treats all fields other than `action.type` as `unknown`. This encourages users to write type guards that check the action object and assert its _specific_ TS type. Inside of those checks, you can access a field with better type safety.
-
-`UnknownAction` is now the default any place in the Redux source that expects an action object.
-
-`AnyAction` still exists for compatibility, but has been marked as deprecated.
-
-Note that [Redux Toolkit's action creators have a `.match()` method](https://redux-toolkit.js.org/api/createAction#actioncreatormatch) that acts as a useful type guard:
-
-```ts
-if (todoAdded.match(someUnknownAction)) {
-  // action is now typed as a PayloadAction<Todo>
-}
-```
-
 </div>
 
 ### Toolkit only
@@ -499,11 +525,11 @@ In practice, we hope these are reasonable tradeoffs. Creating thunks inside of `
 Here's what the new callback syntax looks like:
 
 ```ts
-const createSlice = buildCreateSlice({
+const createSliceWithThunks = buildCreateSlice({
   creators: { asyncThunk: asyncThunkCreator },
 })
 
-const todosSlice = createSlice({
+const todosSlice = createSliceWithThunks({
   name: 'todos',
   initialState: {
     loading: false,
diff --git a/docs/rtk-query/usage-with-typescript.mdx b/docs/rtk-query/usage-with-typescript.mdx
index 7107b83ab3..366da13818 100644
--- a/docs/rtk-query/usage-with-typescript.mdx
+++ b/docs/rtk-query/usage-with-typescript.mdx
@@ -390,6 +390,32 @@ const api = createApi({
 })
 ```
 
+### Typing `dispatch` and `getState`
+
+`createApi` exposes the standard Redux `dispatch` and `getState` methods in several places, such as the `lifecycleApi` argument in lifecycle methods, or the `baseQueryApi` argument passed to `queryFn` methods and base query functions.
+
+Normally, [your application infers `RootState` and `AppDispatch` types from the store setup](../tutorials/typescript.md#define-root-state-and-dispatch-types). Since `createApi` has to be called prior to creating the Redux store and is used as part of the store setup sequence, it can't directly know or use those types - it would cause a circular type inference error.
+
+By default, `dispatch` usages inside of `createApi` will be typed as `ThunkDispatch`, and `getState` usages are typed as `() => unknown`. You will need to assert the type when needed - `getState() as RootState`. You may also include an explicit return type for the function as well, in order to break the circular type inference cycle:
+
+```ts no-transpile
+const api = createApi({
+  baseQuery,
+  endpoints: (build) => ({
+    getTodos: build.query<Todo[], void>({
+      async queryFn() {
+        // highlight-start
+        // Cast state as `RootState`
+        const state = getState() as RootState
+        // highlight-end
+        const text = state.todoTexts[queryFnCalls]
+        return { data: [{ id: `${queryFnCalls++}`, text }] }
+      },
+    }),
+  }),
+})
+```
+
 ### Typing `providesTags`/`invalidatesTags`
 
 RTK Query utilizes a cache tag invalidation system in order to provide [automated re-fetching](./usage/automated-refetching.mdx) of stale data.
diff --git a/docs/rtk-query/usage/customizing-queries.mdx b/docs/rtk-query/usage/customizing-queries.mdx
index 25964af012..8734cc8d2e 100644
--- a/docs/rtk-query/usage/customizing-queries.mdx
+++ b/docs/rtk-query/usage/customizing-queries.mdx
@@ -376,7 +376,13 @@ const axiosBaseQuery =
   > =>
   async ({ url, method, data, params, headers }) => {
     try {
-      const result = await axios({ url: baseUrl + url, method, data, params, headers })
+      const result = await axios({
+        url: baseUrl + url,
+        method,
+        data,
+        params,
+        headers,
+      })
       return { data: result.data }
     } catch (axiosError) {
       const err = axiosError as AxiosError
@@ -608,7 +614,7 @@ The `retry` utility has a `fail` method property attached which can be used to b
 
 ```ts title="Bailing out of error re-tries"
 import { createApi, fetchBaseQuery, retry } from '@reduxjs/toolkit/query/react'
-import type { FetchArgs } from '@reduxjs/toolkit/dist/query/fetchBaseQuery'
+import type { FetchArgs } from '@reduxjs/toolkit/query'
 interface Post {
   id: number
   name: string
diff --git a/docs/tutorials/overview.md b/docs/tutorials/overview.md
index 6c9c65cf78..7bd128bb1f 100644
--- a/docs/tutorials/overview.md
+++ b/docs/tutorials/overview.md
@@ -31,6 +31,8 @@ The [**Redux Toolkit Quick Start tutorial**](./quick-start.mdx) briefly shows ho
 
 We also have a [**TypeScript Quick Start tutorial**](./typescript.md) that briefly shows how to set up and use TypeScript with Redux Toolkit and React-Redux.
 
+If you are using Next.js we have a tutorial specific to using Redux Toolkit with Next.js [**Next.js tutorial**](../usage/nextjs.mdx).
+
 ## Redux Essentials: A Real-World Example
 
 The [**Redux Essentials tutorial**](https://redux.js.org/tutorials/essentials/part-1-overview-concepts) teaches you "how to use Redux the right way", using Redux Toolkit as the standard approach for writing Redux logic.
diff --git a/docs/usage/nextjs.mdx b/docs/usage/nextjs.mdx
new file mode 100644
index 0000000000..d46a5ea3a6
--- /dev/null
+++ b/docs/usage/nextjs.mdx
@@ -0,0 +1,432 @@
+---
+id: nextjs
+title: Redux Toolkit Setup with Next.js
+sidebar_label: Setup with Next.js
+hide_title: true
+---
+
+&nbsp;
+
+# Redux Toolkit Setup with Next.js
+
+:::tip What You'll Learn
+
+- How to set up and use Redux Toolkit with the [Next.js framework](https://nextjs.org/docs)
+
+:::
+
+:::info Prerequisites
+
+- Familiarity with [ES6 syntax and features](https://www.taniarascia.com/es6-syntax-and-feature-overview/)
+- Knowledge of React terminology: [JSX](https://reactjs.org/docs/introducing-jsx.html), [State](https://reactjs.org/docs/state-and-lifecycle.html), [Function Components, Props](https://reactjs.org/docs/components-and-props.html), and [Hooks](https://reactjs.org/docs/hooks-intro.html)
+- Understanding of [Redux terms and concepts](https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow)
+- Working through the [Quick Start tutorial](../tutorials/quick-start.mdx) and [TypeScript Quick Start tutorial](../tutorials/typescript.md) is recommended, and ideally the full [Redux Essentials](https://redux.js.org/tutorials/essentials/part-1-overview-concepts) tutorial as well
+
+:::
+
+## Introduction
+
+[Next.js](https://nextjs.org/docs) is a popular server side rendering framework for React that presents some unique challenges for using Redux properly. These challenges include:
+
+- **Per-request safe Redux store creation**: A Next.js server can handle multiple requests simultaneously. This means that the Redux store should be created per request and that the store should not be shared across requests.
+- **SSR-friendly store hydration**: Next.js applications are rendered twice, first on the server and again on the client. Failure to render the same page contents on both the client and the server will result in a "hydration error". So the Redux store will have to be initialized on the server and then re-initialized on the client with the same data in order to avoid hydration issues.
+- **SPA routing support**: Next.js supports a hybrid model for client side routing. A customer's first page load will get an SSR result from the server. Subsequent page navigation will be handled by the client. This means that with a singleton store defined in the layout, route-specific data will need to be selectively reset on route navigation, while non-route-specific data will need to be retained in the store.
+- **Server caching friendly**: Recent versions of Next.js (specifically applications using the App Router architecture) support aggressive server caching. The ideal store architecture should be compatible with this caching.
+
+There are two architectures for a Next.js application: the [Pages Router](https://nextjs.org/docs/pages/building-your-application/routing/pages-and-layouts) and the [App Router](https://nextjs.org/docs/app/building-your-application/routing).
+
+The Pages Router is the original architecture for Next.js. If you're using the Pages Router, Redux setup is primarily handled by using the [`next-redux-wrapper` library](https://github.com/kirill-konshin/next-redux-wrapper), which integrates a Redux store with the Pages router data fetching methods like `getServerSideProps`.
+
+**This guide will focus on the App Router architecture**, as it is the new default architecture option for Next.js.
+
+### How to Read This Guide
+
+This page assumes that you already have an existing Next.js application based on the App Router architecture.
+
+If you want to follow along, you can create a new empty Next project with `npx create-next-app my-app` - the default prompts will set up a new project with the App Router enabled. Then, add `@reduxjs/toolkit` and `react-redux` as dependencies.
+
+You can also create a new Next+Redux project with `npx create-next-app --example with-redux my-app`, which includes the initial setup pieces described in this page.
+
+## The App Router Architecture and Redux
+
+The primary new feature of the Next.js App Router is the addition of support for React Server Components (RSCs). RSCs are a special type of React component that only renders on the server, as opposed to "client" components that render on **both** the client and the server. RSCs can be defined as `async` functions and return promises during rendering as they make async requests for data to render.
+
+RSCs ability to block for data requests means that with the App Router you no longer have `getServerSideProps` to fetch data for rendering. Any component in the tree can make asychronous requests for data. While this is very convenient it also means thats if you define global variables (like the Redux store) they will be shared across requests. This is a problem because the Redux store could be contaminated with data from other requests.
+
+Based on the architecture of the App Router we have these general recommendations for appropriate use of Redux:
+
+- **No global stores** - Because the Redux store is shared across requests, it should not be defined as a global variable. Instead, the store should be created per request.
+- **RSCs should not read or write the Redux store** - RSCs cannot use hooks or context. They aren't meant to be stateful. Having an RSC read or write values from a global store violates the architecture of the Next.js App Router.
+- **The store should only contain mutable data** - We recommend that you use your Redux sparingly for data intended to be global and mutable.
+
+These recommendations are specific to applications written with the Next.js App Router. Single Page Applications (SPAs) don't execute on the server and therefore can define stores as global variables. SPAs don't need to worry about RSCs since they don't exist in SPAs. And singleton stores can store whatever data you want.
+
+### Folder Structure
+
+Next apps can be created to have the `/app` folder either at the root, or nested under `/src/app`. Your Redux logic should go in a separate folder, alongside the `/app` folder. It's common to put the Redux logic in a folder named `/lib`, but not required.
+
+The file and folder structure inside of that `/lib` folder is up to you, but we generally recommend [a "feature folder"-based structure](https://redux.js.org/style-guide/#structure-files-as-feature-folders-with-single-file-logic) for the Redux logic.
+
+A typical example might look like:
+
+```
+/app
+  layout.tsx
+  page.tsx
+  StoreProvider.tsx
+/lib
+  store.ts
+  /features
+    /todos
+      todosSlice.ts
+```
+
+We'll use that approach for this guide.
+
+## Initial Setup
+
+Similar to the the [RTK TypeScript Tutorial](../tutorials/typescript.md), we need to create a file for the Redux store, as well as the inferred `RootState` and `AppDispatch` types.
+
+However, Next's multi-page architecture requires some differences from that single-page app setup.
+
+### Creating a Redux Store per Request
+
+The first change is to move from defining store as a global to defining a `makeStore` function that returns a new store for each request:
+
+```ts title="lib/store.ts"
+import { configureStore } from '@reduxjs/toolkit'
+
+export const makeStore = () => {
+  return configureStore({
+    reducer: {},
+  })
+}
+
+// Infer the type of makeStore
+export type AppStore = ReturnType<typeof makeStore>
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<AppStore['getState']>
+export type AppDispatch = AppStore['dispatch']
+```
+
+Now we have a function, `makeStore`, that we can use to create a store instance per-request while retaining the strong type safety (if you choose to use TypeScript) that Redux Toolkit provides.
+
+We don't have a `store` variable exported, but we can infer the `RootState` and `AppDispatch` types from the return type of `makeStore`.
+
+You'll also want to create and export [pre-typed versions of the React-Redux hooks as well](../tutorials/typescript.md#define-typed-hooks), to simplify usage later:
+
+```ts title="lib/hooks.ts"
+// file: lib/store.ts noEmit
+import { configureStore } from '@reduxjs/toolkit'
+
+export const makeStore = () => {
+  return configureStore({
+    reducer: {},
+  })
+}
+
+// Infer the type of makeStore
+export type AppStore = ReturnType<typeof makeStore>
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<AppStore['getState']>
+export type AppDispatch = AppStore['dispatch']
+
+/* prettier-ignore */
+
+// file: lib/hooks.ts
+import { useDispatch, useSelector, useStore } from 'react-redux'
+import type { TypedUseSelectorHook } from 'react-redux'
+import type { RootState, AppDispatch, AppStore } from './store'
+
+// highlight-start
+// Use throughout your app instead of plain `useDispatch` and `useSelector`
+export const useAppDispatch: () => AppDispatch = useDispatch
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector
+export const useAppStore: () => AppStore = useStore
+// highlight-end
+```
+
+### Providing the Store
+
+To use this new `makeStore` function we need to create a new "client" component that will create the store and share it using the React-Redux `Provider` component.
+
+```ts title="app/StoreProvider.tsx"
+// file: lib/store.ts noEmit
+import { configureStore } from '@reduxjs/toolkit'
+
+export const makeStore = () => {
+  return configureStore({
+    reducer: {},
+  })
+}
+
+// Infer the type of makeStore
+export type AppStore = ReturnType<typeof makeStore>
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<AppStore['getState']>
+export type AppDispatch = AppStore['dispatch']
+
+/* prettier-ignore */
+
+// file: app/StoreProvider.tsx
+'use client'
+import { useRef } from 'react'
+import { Provider } from 'react-redux'
+// highlight-start
+import { makeStore, AppStore } from '../lib/store'
+// highlight-end
+
+export default function StoreProvider({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  // highlight-start
+  const storeRef = useRef<AppStore>()
+  if (!storeRef.current) {
+    // Create the store instance the first time this renders
+    storeRef.current = makeStore()
+  }
+  // highlight-end
+
+  return <Provider store={storeRef.current}>{children}</Provider>
+}
+```
+
+In this example code we are ensuring that this client component is re-render safe by checking the value of the reference to ensure that the store is only created once. This component will only be rendered once per request on the server, but might be re-rendered multiple times on the client if there are stateful client components located above this component in the tree, or if this component also contains other mutable state that causes a re-render.
+
+:::tip Why Client Components?
+
+Any component that interacts with the Redux store (creating it, providing it, reading from it, or writing to it) needs to be a client component. This is because **accessing the store requires React context, and context is only available in client components.**
+
+:::
+
+The next step is to **include the `StoreProvider` anywhere in the tree above where the store is used**. You can locate the store in the layout component if all the routes using that layout need the store. Or if the store is only used in a specific route you can create and provide the store in that route handler. In all client components further down the tree, you can use the store exactly as you would normally using the hooks provided by `react-redux`.
+
+### Loading Initial Data
+
+If you need to initialize the store with data from the parent component, then define that data as a prop on the client `StoreProvider` component and use a Redux action on the slice to set the data in the store as shown below.
+
+```ts title="src/app/StoreProvider.tsx"
+// file: lib/features/counter/counterSlice.ts noEmit
+import { createSlice } from '@reduxjs/toolkit'
+import type { PayloadAction } from '@reduxjs/toolkit'
+
+const counterSlice = createSlice({
+  name: 'counter',
+  initialState: {
+    value: 0,
+  },
+  reducers: {
+    initializeCount: (state, action: PayloadAction<number>) => {
+      state.value = action.payload
+    },
+  },
+})
+
+export const { initializeCount } = counterSlice.actions
+export default counterSlice.reducer
+
+// file: lib/store.ts noEmit
+import { configureStore } from '@reduxjs/toolkit'
+import counterReducer from './features/counter/counterSlice'
+
+export const makeStore = () =>
+  configureStore({
+    reducer: {
+      counter: counterReducer,
+    },
+  })
+
+// Infer the type of makeStore
+export type AppStore = ReturnType<typeof makeStore>
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<AppStore['getState']>
+// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
+export type AppDispatch = AppStore['dispatch']
+
+/* prettier-ignore */
+
+// file: app/StoreProvider.tsx
+'use client'
+import { useRef } from 'react'
+import { Provider } from 'react-redux'
+import { makeStore, AppStore } from '../lib/store'
+// highlight-start
+import { initializeCount } from '../lib/features/counter/counterSlice'
+// highlight-end
+
+export default function StoreProvider({
+  count,
+  children,
+}: {
+  count: number
+  children: React.ReactNode
+}) {
+  const storeRef = useRef<AppStore | null>(null)
+  if (!storeRef.current) {
+    storeRef.current = makeStore()
+    // highlight-start
+    storeRef.current.dispatch(initializeCount(count))
+    // highlight-end
+  }
+
+  return <Provider store={storeRef.current}>{children}</Provider>
+}
+```
+
+## Additional Configuration
+
+### Per-route state
+
+If you use Next.js's support for client side SPA-style navigation by using `next/navigation`, then when customers navigate from page to page only the route component will be re-rendered. This means that if you have a Redux store created and provided in the layout component it will be preserved across route changes. This is not a problem if you are only using the store for global, mutable data. However, if you are using the store for per-route data then you will need to reset the route-specific data in the store when the route changes.
+
+Shown below is a `ProductName` example component that uses the Redux store to manage the mutable name of a product. The `ProductName` component part of a product detail route. In order to ensure that we have the correct name in the store we need to set the value in the store any time the `ProductName` component is initially rendered, which happens on any route change to the product detail route.
+
+```ts title="app/ProductName.tsx"
+// file: lib/features/product/productSlice.ts noEmit
+import { createSlice } from '@reduxjs/toolkit'
+import type { PayloadAction } from '@reduxjs/toolkit'
+
+export interface Product {
+  name: string
+}
+
+const productSlice = createSlice({
+  name: 'product',
+  initialState: {
+    name: '',
+  },
+  reducers: {
+    initializeProduct: (state, action: PayloadAction<Product>) => {
+      state.name = action.payload.name
+    },
+    setProductName: (state, action: PayloadAction<string>) => {
+      state.name = action.payload
+    },
+  },
+})
+
+export const { initializeProduct, setProductName } = productSlice.actions
+export default productSlice.reducer
+
+// file: lib/store.ts noEmit
+import { configureStore } from '@reduxjs/toolkit'
+import productReducer from './features/product/productSlice'
+
+export const makeStore = () =>
+  configureStore({
+    reducer: {
+      product: productReducer,
+    },
+  })
+
+// Infer the type of makeStore
+export type AppStore = ReturnType<typeof makeStore>
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<AppStore['getState']>
+// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
+export type AppDispatch = AppStore['dispatch']
+
+// file: lib/hooks.ts noEmit
+import { useDispatch, useSelector, useStore } from 'react-redux'
+import type { TypedUseSelectorHook } from 'react-redux'
+import type { RootState, AppDispatch, AppStore } from './store'
+
+// highlight-start
+// Use throughout your app instead of plain `useDispatch` and `useSelector`
+export const useAppDispatch: () => AppDispatch = useDispatch
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector
+export const useAppStore: () => AppStore = useStore
+// highlight-end
+
+/* prettier-ignore */
+
+// file: app/ProductName.tsx
+'use client'
+import { useRef } from 'react'
+import { useAppSelector, useAppDispatch, useAppStore } from '../lib/hooks'
+import {
+  initializeProduct,
+  setProductName,
+  Product,
+} from '../lib/features/product/productSlice'
+
+export default function ProductName({ product }: { product: Product }) {
+  // highlight-start
+  // Initialize the store with the product information
+  const store = useAppStore()
+  const initialized = useRef(false)
+  if (!initialized.current) {
+    store.dispatch(initializeProduct(product))
+    initialized.current = true
+  }
+  const name = useAppSelector((state) => state.product.name)
+  const dispatch = useAppDispatch()
+  // highlight-end
+
+  return (
+    <input
+      value={name}
+      onChange={(e) => dispatch(setProductName(e.target.value))}
+    />
+  )
+}
+```
+
+Here we are using the same intialization pattern as before, of dispatching actions to the store, to set the route-specific data. The `initialized` ref is used to ensure that the store is only initialized once per route change.
+
+It is worth noting that initializing the store with a `useEffect` would not work because `useEffect` only runs on the client. This would result in hydration errors or flicker because the result from a server side render would not match the result from the client side render.
+
+### Caching
+
+The App Router has four seperate caches including `fetch` request and route caches. The most likely cache to cause issues is the route cache. If you have an application that accepts login you may have routes (e.g. the home route, `/`) that render different data based on the user you will need to disable the route cache by using the [`dynamic` export from the route handler](https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#dynamic):
+
+```ts
+export const dynamic = 'force-dynamic'
+```
+
+After a mutation you should also invalidate the cache by calling (`revalidatePath`)[https://nextjs.org/docs/app/api-reference/functions/revalidatePath] or (`revalidateTag`)[https://nextjs.org/docs/app/api-reference/functions/revalidateTag] as appropriate.
+
+### RTK Query
+
+We recommend using RTK Query for data fetching **on the client only**. Data fetching on the server should use `fetch` requests from `async` RSCs.
+
+You can learn more about Redux Toolkit Query in the [Redux Toolkit Query tutorial](https://redux-toolkit.js.org/tutorials/rtk-query).
+
+:::note
+
+In the future, RTK Query may be able to receive data fetched on the server via React Server Components, but that is a future capability that will require changes to both React and RTK Query.
+
+:::
+
+## Checking Your Work
+
+There are three key areas that you should check to ensure that you have set up Redux Toolkit correctly:
+
+- **Server Side Rendering** - Check the HTML output of the server to ensure that the data in the Redux store is present in the server side rendered output.
+- **Route Change** - Navigate between pages on the same route as well as between different routes to ensure that route-specific data is initialized properly.
+- **Mutations** - Check that the store is compatible with the Next.js App Router caches by performing a mutation and then navigating away from the route and back to the original route to ensure that the data is updated.
+
+## Overall Recommendations
+
+The App Router presents a dramatically different archtecture for React applications from either the Pages Router or a SPA application. We recommend rethinking your approach to state management in the light of this new architecture. In SPA applications it's not unusual to have a large store that contains all the data, both mutable and immutable, required to drive the application. For App Router applications we recommend that you should:
+
+- **only use Redux for globally shared, mutable data**
+- use a combination of Next.js state (search params, route parameters, form state, etc.), React context and React hooks for all other state management.
+
+## What You've Learned
+
+That was a brief overview of how to set up and use Redux Toolkit with the App Router:
+
+:::tip Summary
+
+- **Create a Redux store per request by using `configureStore` wrapped in a `makeStore` function**
+- **Provide the Redux store to the React application components using a "client" component**
+- **Only interact with the Redux store in client components** because only client components have access to React context
+- **Use the store as you normally would using the hooks provided in React-Redux**
+- **You need to account for the case where you have per-route state in a global store located in the layout**
+
+## What's Next?
+
+We recommend going through [**the "Redux Essentials" and "Redux Fundamentals" tutorials in the Redux core docs**](https://redux.js.org/tutorials/index), which will give you a complete understanding of how Redux works, what Redux Toolkit does, and how to use it correctly.
diff --git a/docs/usage/usage-with-typescript.md b/docs/usage/usage-with-typescript.md
index 73734f605d..aadec00ccd 100644
--- a/docs/usage/usage-with-typescript.md
+++ b/docs/usage/usage-with-typescript.md
@@ -326,9 +326,9 @@ const blogSlice = createSlice({
 
 ### Generated Action Types for Slices
 
-As TS cannot combine two string literals (`slice.name` and the key of `actionMap`) into a new literal, all actionCreators created by `createSlice` are of type 'string'. This is usually not a problem, as these types are only rarely used as literals.
+`createSlice` generates action type strings by combining the `name` field from the slice with the field name of the reducer function, like `'test/increment'`. This is strongly typed as the exact value, thanks to TS's string literal analysis.
 
-In most cases that `type` would be required as a literal, the `slice.action.myAction.match` [type predicate](https://www.typescriptlang.org/docs/handbook/advanced-types.html#using-type-predicates) should be a viable alternative:
+You can also use the `slice.action.myAction.match` [type predicate](https://www.typescriptlang.org/docs/handbook/advanced-types.html#using-type-predicates), which will narrow down an action object to the exact type:
 
 ```ts {10}
 const slice = createSlice({
@@ -339,6 +339,9 @@ const slice = createSlice({
   },
 })
 
+type incrementType = typeof slice.actions.increment.type
+// type incrementType = 'test/increment'
+
 function myCustomMiddleware(action: Action) {
   if (slice.actions.increment.match(action)) {
     // `action` is narrowed down to the type `PayloadAction<number>` here.
@@ -408,6 +411,59 @@ type AtLeastOne<T extends Record<string, any>> = keyof T extends infer K
 type AtLeastOneUserField = AtLeastOne<User>
 ```
 
+### Typing Async Thunks Inside `createSlice`
+
+As of 2.0, `createSlice` allows [defining thunks inside of `reducers` using a callback syntax](../api/createSlice.mdx/#the-reducers-creator-callback-notation).
+
+Typing for the `create.asyncThunk` method works in the same way as [`createAsyncThunk`](#createasyncthunk), with one key difference.
+
+A type for `state` and/or `dispatch` _cannot_ be provided as part of the `ThunkApiConfig`, as this would cause circular types.
+
+Instead, it is necessary to assert the type when needed - `getState() as RootState`. You may also include an explicit return type for the payload function as well, in order to break the circular type inference cycle.
+
+```ts no-transpile
+create.asyncThunk<Todo, string, { rejectValue: { error: string } }>(
+  // highlight-start
+  // may need to include an explicit return type
+  async (id: string, thunkApi): Promise<Todo> => {
+    // Cast types for `getState` and `dispatch` manually
+    const state = thunkApi.getState() as RootState
+    const dispatch = thunkApi.dispatch as AppDispatch
+    // highlight-end
+    try {
+      const todo = await fetchTodo()
+      return todo
+    } catch (e) {
+      throw thunkApi.rejectWithValue({
+        error: 'Oh no!',
+      })
+    }
+  }
+)
+```
+
+For common thunk API configuration options, a [`withTypes` helper](../usage/usage-with-typescript#defining-a-pre-typed-createasyncthunk) is provided:
+
+```ts no-transpile
+reducers: (create) => {
+  const createAThunk =
+    create.asyncThunk.withTypes<{ rejectValue: { error: string } }>()
+
+  return {
+    fetchTodo: createAThunk<Todo, string>(async (id, thunkApi) => {
+      throw thunkApi.rejectWithValue({
+        error: 'Oh no!',
+      })
+    }),
+    fetchTodos: createAThunk<Todo[], string>(async (id, thunkApi) => {
+      throw thunkApi.rejectWithValue({
+        error: 'Oh no, not again!',
+      })
+    }),
+  }
+}
+```
+
 ### Wrapping `createSlice`
 
 If you need to reuse reducer logic, it is common to write ["higher-order reducers"](https://redux.js.org/recipes/structuring-reducers/reusing-reducer-logic#customizing-behavior-with-higher-order-reducers) that wrap a reducer function with additional common behavior. This can be done with `createSlice` as well, but due to the complexity of the types for `createSlice`, you have to use the `SliceCaseReducers` and `ValidateSliceCaseReducers` types in a very specific way.
diff --git a/errors.json b/errors.json
index d0a9d06a44..ac6286a866 100644
--- a/errors.json
+++ b/errors.json
@@ -1,42 +1,41 @@
 {
-  "0": "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer",
-  "1": "A case reducer on a non-draftable value must not return undefined",
-  "2": ": ",
-  "3": "prepareAction did not return an object",
-  "4": "\"reducer\" is a required argument, and must be a function or an object of functions that can be passed to combineReducers",
-  "5": "when using a middleware builder function, an array of middleware must be returned",
-  "6": "each middleware provided to configureStore must be a function",
-  "7": "\"enhancers\" field must be a callback",
-  "8": "\"enhancers\" callback must return an array",
-  "9": "each enhancer provided to configureStore must be a function",
-  "10": "`name` is a required option for createSlice",
-  "11": "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice",
-  "12": "selectState returned undefined for an uninjected slice reducer",
-  "13": "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.",
-  "14": "The slice reducer for key \"\" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.",
-  "15": "original must be used on state Proxy",
-  "16": "Creating or removing a listener requires one of the known fields for matching an action",
-  "17": "Unsubscribe not initialized",
-  "18": ": getOriginalState can only be called synchronously",
-  "19": "`builder.addCase` should only be called before calling `builder.addMatcher`",
-  "20": "`builder.addCase` should only be called before calling `builder.addDefaultCase`",
-  "21": "addCase cannot be called with two reducers for the same action type",
-  "22": "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`",
-  "23": "`builder.addDefaultCase` can only be called once",
-  "24": " is not a function",
-  "25": "When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.",
-  "26": "Warning: Middleware for RTK-Query API at reducerPath \"\" has not been added to the store.\nYou must add the middleware for RTK-Query to function correctly!",
-  "27": "Warning: Middleware for RTK-Query API at reducerPath \"\" has not been added to the store.\n    You must add the middleware for RTK-Query to function correctly!",
-  "28": "Cannot refetch a query that has not been started yet.",
-  "29": "`builder.addCase` cannot be called with an empty action type",
-  "30": "`builder.addCase` cannot be called with two reducers for the same action type",
-  "31": "\"middleware\" field must be a callback",
-  "32": "When using custom hooks for context, all  hooks need to be provided: .\\nHook  was either not provided or not a function.",
-  "33": "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.",
-  "34": "selectSlice returned undefined for an uninjected slice reducer",
-  "35": "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.",
-  "36": "`context.addCase` cannot be called with an empty action type",
-  "37": "`context.addCase` cannot be called with two reducers for the same action type: type",
-  "38": "No insert provided for key not already in map",
-  "39": "\\`builder.addCase\\` cannot be called with two reducers for the same action type ''"
-}
\ No newline at end of file
+  "0": "prepareAction did not return an object",
+  "1": "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers",
+  "2": "`middleware` field must be a callback",
+  "3": "when using a middleware builder function, an array of middleware must be returned",
+  "4": "each middleware provided to configureStore must be a function",
+  "5": "`enhancers` field must be a callback",
+  "6": "`enhancers` callback must return an array",
+  "7": "each enhancer provided to configureStore must be a function",
+  "8": "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer",
+  "9": "A case reducer on a non-draftable value must not return undefined",
+  "10": "No insert provided for key not already in map",
+  "11": "`name` is a required option for createSlice",
+  "12": "`context.addCase` cannot be called with an empty action type",
+  "13": "`context.addCase` cannot be called with two reducers for the same action type: type",
+  "14": "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice",
+  "15": "selectSlice returned undefined for an uninjected slice reducer",
+  "16": "selectState returned undefined for an uninjected slice reducer",
+  "17": "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.",
+  "18": "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.",
+  "19": "A state mutation was detected between dispatches, in the path ''.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)",
+  "20": "A state mutation was detected inside a dispatch, in the path: . Take a look at the reducer(s) handling the action . (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)",
+  "21": "Creating or removing a listener requires one of the known fields for matching an action",
+  "22": "Unsubscribe not initialized",
+  "23": ": getOriginalState can only be called synchronously",
+  "24": "The slice reducer for key \"\" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.",
+  "25": "original must be used on state Proxy",
+  "26": "`builder.addCase` should only be called before calling `builder.addMatcher`",
+  "27": "`builder.addCase` should only be called before calling `builder.addDefaultCase`",
+  "28": "`builder.addCase` cannot be called with an empty action type",
+  "29": "`builder.addCase` cannot be called with two reducers for the same action type ''",
+  "30": "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`",
+  "31": "`builder.addDefaultCase` can only be called once",
+  "32": " is not a function",
+  "33": "When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.",
+  "34": "Warning: Middleware for RTK-Query API at reducerPath \"\" has not been added to the store.\nYou must add the middleware for RTK-Query to function correctly!",
+  "35": "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.",
+  "36": "When using custom hooks for context, all  hooks need to be provided: .\\nHook  was either not provided or not a function.",
+  "37": "Warning: Middleware for RTK-Query API at reducerPath \"\" has not been added to the store.\n    You must add the middleware for RTK-Query to function correctly!",
+  "38": "Cannot refetch a query that has not been started yet."
+}
diff --git a/packages/toolkit/README.md b/packages/toolkit/README.md
index 6b5dd2b7a4..40c1239490 100644
--- a/packages/toolkit/README.md
+++ b/packages/toolkit/README.md
@@ -6,24 +6,28 @@
 
 **The official, opinionated, batteries-included toolset for efficient Redux development**
 
-(Formerly known as "Redux Starter Kit")
-
 ## Installation
 
-### Using Create React App
+### Create a React Redux App
 
-The recommended way to start new apps with React and Redux Toolkit is by using the [official Redux+JS template](https://github.com/reduxjs/cra-template-redux) for [Create React App](https://github.com/facebook/create-react-app), which takes advantage of React Redux's integration with React components.
+The recommended way to start new apps with React and Redux Toolkit is by using [our official Redux Toolkit + TS template for Vite](https://github.com/reduxjs/redux-templates), or by creating a new Next.js project using [Next's `with-redux` template](https://github.com/vercel/next.js/tree/canary/examples/with-redux).
 
-```sh
-npx create-react-app my-app --template redux
-```
+Both of these already have Redux Toolkit and React-Redux configured appropriately for that build tool, and come with a small example app that demonstrates how to use several of Redux Toolkit's features.
 
-Or if you are a TypeScript user, use [cra-template-redux-typescript](https://github.com/reduxjs/cra-template-redux-typescript), which is based on that template
+```bash
+# Vite with our Redux+TS template
+# (using the `degit` tool to clone and extract the template)
+npx degit reduxjs/redux-templates/packages/vite-template-redux my-app
 
-```sh
-npx create-react-app my-app --template redux-typescript
+# Next.js using the `with-redux` template
+npx create-next-app --example with-redux my-app
 ```
 
+We do not currently have official React Native templates, but recommend these templates for standard React Native and for Expo:
+
+- https://github.com/rahsheen/react-native-template-redux-typescript
+- https://github.com/rahsheen/expo-template-redux-typescript
+
 ### An Existing App
 
 Redux Toolkit is available as a package on NPM for use with a module bundler or in a Node application:
@@ -36,8 +40,13 @@ npm install @reduxjs/toolkit
 yarn add @reduxjs/toolkit
 ```
 
-It is also available as a precompiled UMD package that defines a `window.RTK` global variable.
-The UMD package can be used as a [`<script>` tag](https://unpkg.com/@reduxjs/toolkit/dist/redux-toolkit.umd.js) directly.
+The package includes a precompiled ESM build that can be used as a [`<script type="module">` tag](https://unpkg.com/@reduxjs/toolkit/dist/redux-toolkit.browser.mjs) directly in the browser.
+
+## Documentation
+
+The Redux Toolkit docs are available at **https://redux-toolkit.js.org**, including API references and usage guides for all of the APIs included in Redux Toolkit.
+
+The Redux core docs at https://redux.js.org includes the full Redux tutorials, as well usage guides on general Redux patterns.
 
 ## Purpose
 
@@ -67,6 +76,8 @@ Redux Toolkit includes these APIs:
 - `createEntityAdapter()`: generates a set of reusable reducers and selectors to manage normalized data in the store
 - The `createSelector()` utility from the [Reselect](https://github.com/reduxjs/reselect) library, re-exported for ease of use.
 
+For details, see [the Redux Toolkit API Reference section in the docs](https://redux-toolkit.js.org/api/configureStore).
+
 ## RTK Query
 
 **RTK Query** is provided as an optional addon within the `@reduxjs/toolkit` package. It is purpose-built to solve the use case of data fetching and caching, supplying a compact, but powerful toolset to define an API interface layer for your app. It is intended to simplify common cases for loading data in a web application, eliminating the need to hand-write data fetching & caching logic yourself.
@@ -93,7 +104,3 @@ RTK Query includes these APIs:
 - `setupListeners()`: A utility used to enable refetchOnMount and refetchOnReconnect behaviors.
 
 See the [**RTK Query Overview**](https://redux-toolkit.js.org/rtk-query/overview) page for more details on what RTK Query is, what problems it solves, and how to use it.
-
-## Documentation
-
-The Redux Toolkit docs are available at **https://redux-toolkit.js.org**.
diff --git a/packages/toolkit/package.json b/packages/toolkit/package.json
index 5e58059762..1ff0ebcf2c 100644
--- a/packages/toolkit/package.json
+++ b/packages/toolkit/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@reduxjs/toolkit",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.2",
   "description": "The official, opinionated, batteries-included toolset for efficient Redux development",
   "author": "Mark Erikson <mark@isquaredsoftware.com>",
   "license": "MIT",
@@ -114,7 +114,7 @@
     "immer": "^10.0.3",
     "redux": "^5.0.0-rc.1",
     "redux-thunk": "^3.0.0-rc.0",
-    "reselect": "^5.0.0-beta.1"
+    "reselect": "^5.0.0-rc.0"
   },
   "peerDependencies": {
     "react": "^16.9.0 || ^17.0.0 || ^18",
diff --git a/packages/toolkit/src/configureStore.ts b/packages/toolkit/src/configureStore.ts
index d8cdff64d5..93bf59017a 100644
--- a/packages/toolkit/src/configureStore.ts
+++ b/packages/toolkit/src/configureStore.ts
@@ -140,12 +140,12 @@ export function configureStore<
     rootReducer = combineReducers(reducer) as unknown as Reducer<S, A, P>
   } else {
     throw new Error(
-      '"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'
+      '`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers'
     )
   }
 
   if (!IS_PRODUCTION && middleware && typeof middleware !== 'function') {
-    throw new Error('"middleware" field must be a callback')
+    throw new Error('`middleware` field must be a callback')
   }
 
   let finalMiddleware: Tuple<Middlewares<S>>
@@ -184,7 +184,7 @@ export function configureStore<
   const getDefaultEnhancers = buildGetDefaultEnhancers<M>(middlewareEnhancer)
 
   if (!IS_PRODUCTION && enhancers && typeof enhancers !== 'function') {
-    throw new Error('"enhancers" field must be a callback')
+    throw new Error('`enhancers` field must be a callback')
   }
 
   let storeEnhancers =
@@ -193,7 +193,7 @@ export function configureStore<
       : getDefaultEnhancers()
 
   if (!IS_PRODUCTION && !Array.isArray(storeEnhancers)) {
-    throw new Error('"enhancers" callback must return an array')
+    throw new Error('`enhancers` callback must return an array')
   }
   if (
     !IS_PRODUCTION &&
diff --git a/packages/toolkit/src/createDraftSafeSelector.ts b/packages/toolkit/src/createDraftSafeSelector.ts
index fb853397be..6fe8d267d2 100644
--- a/packages/toolkit/src/createDraftSafeSelector.ts
+++ b/packages/toolkit/src/createDraftSafeSelector.ts
@@ -1,5 +1,5 @@
 import { current, isDraft } from 'immer'
-import { createSelectorCreator, defaultMemoize } from 'reselect'
+import { createSelectorCreator, weakMapMemoize } from 'reselect'
 
 export const createDraftSafeSelectorCreator: typeof createSelectorCreator = (
   ...args: unknown[]
@@ -22,4 +22,4 @@ export const createDraftSafeSelectorCreator: typeof createSelectorCreator = (
  * @public
  */
 export const createDraftSafeSelector =
-  createDraftSafeSelectorCreator(defaultMemoize)
+  createDraftSafeSelectorCreator(weakMapMemoize)
diff --git a/packages/toolkit/src/immutableStateInvariantMiddleware.ts b/packages/toolkit/src/immutableStateInvariantMiddleware.ts
index 3d63f992f4..90f3a8ebe1 100644
--- a/packages/toolkit/src/immutableStateInvariantMiddleware.ts
+++ b/packages/toolkit/src/immutableStateInvariantMiddleware.ts
@@ -3,28 +3,6 @@ import { getTimeMeasureUtils } from './utils'
 
 type EntryProcessor = (key: string, value: any) => any
 
-const isProduction: boolean = process.env.NODE_ENV === 'production'
-const prefix: string = 'Invariant failed'
-
-// Throw an error if the condition fails
-// Strip out error messages for production
-// > Not providing an inline default argument for message as the result is smaller
-function invariant(condition: any, message?: string) {
-  if (condition) {
-    return
-  }
-  // Condition not passed
-
-  // In production we strip the message but still throw
-  if (isProduction) {
-    throw new Error(prefix)
-  }
-
-  // When not in production we allow the message to pass through
-  // *This block will be removed in production builds*
-  throw new Error(`${prefix}: ${message || ''}`)
-}
-
 /**
  * The default `isImmutable` function.
  *
@@ -62,7 +40,7 @@ function trackProperties(
   const tracked: Partial<TrackedProperty> = { value: obj }
 
   if (!isImmutable(obj) && !checkedObjects.has(obj)) {
-    checkedObjects.add(obj);
+    checkedObjects.add(obj)
     tracked.children = {}
 
     for (const key in obj) {
@@ -248,12 +226,13 @@ export function createImmutableStateInvariantMiddleware(
           // Track before potentially not meeting the invariant
           tracker = track(state)
 
-          invariant(
-            !result.wasMutated,
-            `A state mutation was detected between dispatches, in the path '${
-              result.path || ''
-            }'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`
-          )
+          if (result.wasMutated) {
+            throw new Error(
+              `A state mutation was detected between dispatches, in the path '${
+                result.path || ''
+              }'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`
+            )
+          }
         })
 
         const dispatchedAction = next(action)
@@ -265,15 +244,15 @@ export function createImmutableStateInvariantMiddleware(
           // Track before potentially not meeting the invariant
           tracker = track(state)
 
-          result.wasMutated &&
-            invariant(
-              !result.wasMutated,
+          if (result.wasMutated) {
+            throw new Error(
               `A state mutation was detected inside a dispatch, in the path: ${
                 result.path || ''
               }. Take a look at the reducer(s) handling the action ${stringify(
                 action
               )}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`
             )
+          }
         })
 
         measureUtils.warnIfExceeded()
diff --git a/packages/toolkit/src/index.ts b/packages/toolkit/src/index.ts
index 787c51e5ef..a1b7277b88 100644
--- a/packages/toolkit/src/index.ts
+++ b/packages/toolkit/src/index.ts
@@ -17,12 +17,7 @@ export {
   defaultMemoize,
   weakMapMemoize,
 } from 'reselect'
-export type {
-  Selector,
-  OutputParametricSelector,
-  OutputSelector,
-  ParametricSelector,
-} from 'reselect'
+export type { Selector, OutputSelector } from 'reselect'
 export {
   createDraftSafeSelector,
   createDraftSafeSelectorCreator,
diff --git a/packages/toolkit/src/mapBuilders.ts b/packages/toolkit/src/mapBuilders.ts
index f381b90418..5c6ac60010 100644
--- a/packages/toolkit/src/mapBuilders.ts
+++ b/packages/toolkit/src/mapBuilders.ts
@@ -166,7 +166,8 @@ export function executeReducerBuilderCallback<S>(
       }
       if (type in actionsMap) {
         throw new Error(
-          `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`
+          '`builder.addCase` cannot be called with two reducers for the same action type ' +
+            `'${type}'`
         )
       }
       actionsMap[type] = reducer
diff --git a/packages/toolkit/src/query/createApi.ts b/packages/toolkit/src/query/createApi.ts
index 8de1107c3d..eb1184eedb 100644
--- a/packages/toolkit/src/query/createApi.ts
+++ b/packages/toolkit/src/query/createApi.ts
@@ -11,7 +11,7 @@ import { DefinitionType, isQueryDefinition } from './endpointDefinitions'
 import { nanoid } from './core/rtkImports'
 import type { UnknownAction } from '@reduxjs/toolkit'
 import type { NoInfer } from './tsHelpers'
-import { defaultMemoize } from 'reselect'
+import { weakMapMemoize } from 'reselect'
 
 export interface CreateApiOptions<
   BaseQuery extends BaseQueryFn,
@@ -253,7 +253,7 @@ export function buildCreateApi<Modules extends [Module<any>, ...Module<any>[]]>(
   ...modules: Modules
 ): CreateApi<Modules[number]['name']> {
   return function baseCreateApi(options) {
-    const extractRehydrationInfo = defaultMemoize((action: UnknownAction) =>
+    const extractRehydrationInfo = weakMapMemoize((action: UnknownAction) =>
       options.extractRehydrationInfo?.(action, {
         reducerPath: (options.reducerPath ?? 'api') as any,
       })
@@ -304,7 +304,7 @@ export function buildCreateApi<Modules extends [Module<any>, ...Module<any>[]]>(
       },
       apiUid: nanoid(),
       extractRehydrationInfo,
-      hasRehydrationInfo: defaultMemoize(
+      hasRehydrationInfo: weakMapMemoize(
         (action) => extractRehydrationInfo(action) != null
       ),
     }
diff --git a/packages/toolkit/src/tests/configureStore.test.ts b/packages/toolkit/src/tests/configureStore.test.ts
index 1a7cf100a1..d122395fd8 100644
--- a/packages/toolkit/src/tests/configureStore.test.ts
+++ b/packages/toolkit/src/tests/configureStore.test.ts
@@ -102,7 +102,7 @@ describe('configureStore', async () => {
   describe('given no reducer', () => {
     it('throws', () => {
       expect(configureStore).toThrow(
-        '"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'
+        '`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers'
       )
     })
   })
@@ -126,7 +126,7 @@ describe('configureStore', async () => {
     it('throws an error requiring a callback', () => {
       // @ts-expect-error
       expect(() => configureStore({ middleware: [], reducer })).toThrow(
-        '"middleware" field must be a callback'
+        '`middleware` field must be a callback'
       )
     })
   })
@@ -291,14 +291,14 @@ describe('configureStore', async () => {
     describe('invalid arguments', () => {
       test('enhancers is not a callback', () => {
         expect(() => configureStore({ reducer, enhancers: [] as any })).toThrow(
-          '"enhancers" field must be a callback'
+          '`enhancers` field must be a callback'
         )
       })
 
       test('callback fails to return array', () => {
         expect(() =>
           configureStore({ reducer, enhancers: (() => {}) as any })
-        ).toThrow('"enhancers" callback must return an array')
+        ).toThrow('`enhancers` callback must return an array')
       })
 
       test('array contains non-function', () => {
diff --git a/website/sidebars.json b/website/sidebars.json
index 6854804533..6b3c684ee2 100644
--- a/website/sidebars.json
+++ b/website/sidebars.json
@@ -30,7 +30,8 @@
         },
         "usage/usage-guide",
         "usage/usage-with-typescript",
-        "usage/immer-reducers"
+        "usage/immer-reducers",
+        "usage/nextjs"
       ]
     },
     {
@@ -75,7 +76,8 @@
             "api/createSelector",
             "api/matching-utilities",
             "api/other-exports",
-            "api/codemods"
+            "api/codemods",
+            { "type": "link", "label": "Error Messages", "href": "/errors" }
           ]
         }
       ]
diff --git a/website/src/pages/errors.js b/website/src/pages/errors.js
new file mode 100644
index 0000000000..17b86e42b9
--- /dev/null
+++ b/website/src/pages/errors.js
@@ -0,0 +1,61 @@
+import React from 'react'
+import Layout from '@theme/Layout'
+import { useLocation } from '@docusaurus/router'
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext'
+import styles from './styles.module.css'
+import errorCodes from '../../../errors.json'
+
+function Errors() {
+  const location = useLocation()
+  const context = useDocusaurusContext()
+  const { siteConfig = {} } = context
+  const errorCode = new URLSearchParams(location.search).get('code')
+  const error = errorCodes[errorCode]
+
+  return (
+    <Layout
+      title={`${siteConfig.title} - ${siteConfig.tagline}`}
+      description={siteConfig.tagline}
+    >
+      <main className={styles.mainFull}>
+        <h1>Production Error Codes</h1>
+        <p>
+          When Redux Toolkit is built and running in production, error text is
+          replaced by indexed error codes to save on bundle size. These errors
+          will provide a link to this page with more information about the error
+          below.
+        </p>
+        {error && (
+          <React.Fragment>
+            <p>
+              <strong>
+                The full text of the error you just encountered is:
+              </strong>
+            </p>
+            <code className={styles.errorDetails}>{error}</code>
+          </React.Fragment>
+        )}
+
+        <h2>All Error Codes</h2>
+        <table>
+          <thead>
+            <tr>
+              <th>Code</th>
+              <th>Message</th>
+            </tr>
+          </thead>
+          <tbody>
+            {Object.keys(errorCodes).map((code) => (
+              <tr>
+                <td>{code}</td>
+                <td>{errorCodes[code]}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </main>
+    </Layout>
+  )
+}
+
+export default Errors
diff --git a/website/src/pages/styles.module.css b/website/src/pages/styles.module.css
index 94ab9c7514..e8184048bd 100644
--- a/website/src/pages/styles.module.css
+++ b/website/src/pages/styles.module.css
@@ -80,3 +80,32 @@
   font-size: 30px;
   margin-bottom: 55px;
 }
+
+.mainFull {
+  padding: 34px 16px;
+  width: 100%;
+  max-width: var(--ifm-container-width);
+  margin: 0px auto;
+}
+.mainFull h1 {
+  font-size: 3rem;
+  color: var(--ifm-heading-color);
+  font-weight: var(--ifm-heading-font-weight);
+  line-height: var(--ifm-heading-line-height);
+}
+
+.mainFull p {
+  margin-bottom: var(--ifm-leading);
+  margin-top: 0;
+}
+
+
+.errorDetails {
+  color: #ff6464;
+  border-radius: 0.5rem;
+  padding: 1rem;
+  margin: 30px 0;
+  font-weight: bold;
+  background-color: rgba(255, 100, 100, 0.1);
+  display: block;
+}
diff --git a/yarn.lock b/yarn.lock
index 6814bff42f..958ef89c26 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7077,7 +7077,7 @@ __metadata:
     query-string: ^7.0.1
     redux: ^5.0.0-rc.1
     redux-thunk: ^3.0.0-rc.0
-    reselect: ^5.0.0-beta.1
+    reselect: ^5.0.0-rc.0
     rimraf: ^3.0.2
     size-limit: ^4.11.0
     tslib: ^1.10.0
@@ -25611,10 +25611,10 @@ fsevents@^1.2.7:
   languageName: node
   linkType: hard
 
-"reselect@npm:^5.0.0-beta.1":
-  version: 5.0.0-beta.1
-  resolution: "reselect@npm:5.0.0-beta.1"
-  checksum: dd707e2285c6c4d27c245634e87cf12ef5043cf01c48478f80b3e178efa8f4cd8576d56ac2691180a63704532fb3f12861df81b66ddd7819decbf64d6908779e
+"reselect@npm:^5.0.0-rc.0":
+  version: 5.0.0-rc.0
+  resolution: "reselect@npm:5.0.0-rc.0"
+  checksum: 3de8f67e543da56261e97a4db9a677544637ec59f037b651a617cf91fb9cb32d540dc8a9aa8a36f7dbcc9997bd4c4391c53e5ac9298b983a0da9bf576688e5db
   languageName: node
   linkType: hard