next 16.2.9 → 16.2.10

package/dist/docs/01-app/02-guides/server-actions.md

@@ -0,0 +1,180 @@
+---
+title: Server Actions and Mutations
+nav_title: Server Actions
+description: How Server Actions work in Next.js, including the single-roundtrip response model, sequential dispatch, security, and caching integration.
+related:
+  title: Next steps
+  description: Learn more about creating, securing, and configuring Server Actions.
+  links:
+    - app/getting-started/mutating-data
+    - app/guides/forms
+    - app/guides/data-security
+    - app/api-reference/directives/use-server
+    - app/api-reference/functions/revalidatePath
+    - app/api-reference/functions/revalidateTag
+    - app/api-reference/functions/redirect
+    - app/api-reference/functions/refresh
+    - app/api-reference/config/next-config-js/serverActions
+---
+
+A **Server Action** is a [React Server Function](https://react.dev/reference/rsc/server-functions) invoked through React's action mechanisms, such as `<form action>`, `<button formAction>`, or a client-side transition.
+
+You create one by adding the [`'use server'`](/docs/app/api-reference/directives/use-server) directive, then invoke it from a form, or from an event handler or `useEffect` wrapped in `startTransition`. For the basics of creating and invoking Server Functions, see [Mutating data](/docs/app/getting-started/mutating-data) and the [Forms guide](/docs/app/guides/forms).
+
+This page covers the parts of Server Actions that are specific to Next.js: how they commonly map to mutations, how the response carries both returned data and re-rendered UI, how the client dispatches them, the security boundary the framework enforces, and the configuration available.
+
+## Sequential dispatch on the client
+
+Next.js dispatches Server Actions one at a time per client. If a user triggers three actions in quick succession, the second waits for the first to finish, then the third waits for the second. This keeps the re-rendered server tree consistent with the action result that produced it.
+
+A consequence: do not rely on `Promise.all` to parallelize Server Actions from the client. If you need parallel work, do it inside a single Server Action, fetch in parallel from a [Server Component](/docs/app/getting-started/fetching-data#server-components), or use a [Route Handler](/docs/app/guides/backend-for-frontend#manipulating-data) for non-mutation requests.
+
+> **Good to know:** This is a property of the client dispatcher, not of Server Functions in general. Server-side, an action runs in its own request and can do anything an async function can do.
+
+## A single response carries data and UI
+
+When a Server Action triggers an immediate revalidation, Next.js does the work inside one HTTP request: it runs the action, then re-renders the current route server-side. The response that comes back contains both pieces in the same Flight stream:
+
+- The action's return value, consumed by `useActionState` or the awaited promise on the client.
+- A newly rendered [RSC Payload](/docs/app/glossary#rsc-payload) for the current route, which the client commits as a seeded navigation.
+
+Your application code does not need a follow-up fetch to see the updated UI for the current page.
+
+A re-render is included in the same response when the action does any of these:
+
+- Calls [`updateTag`](/docs/app/api-reference/functions/updateTag) or [`revalidatePath`](/docs/app/api-reference/functions/revalidatePath) to immediately invalidate cached data.
+- Calls [`refresh`](/docs/app/api-reference/functions/refresh) to refetch the current route's RSC Payload.
+- Mutates cookies through [`cookies()`](/docs/app/api-reference/functions/cookies#understanding-cookie-behavior-in-server-functions). Setting or deleting a cookie automatically re-renders the current page so the UI reflects the new value.
+- Calls [`redirect`](/docs/app/api-reference/functions/redirect). The response navigates the router and streams the destination's RSC Payload.
+
+```ts filename="app/posts/actions.ts"
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { auth } from '@/lib/auth'
+import { db } from '@/lib/db'
+
+export async function createPost(formData: FormData) {
+  const session = await auth()
+  if (!session?.user) throw new Error('Unauthorized')
+
+  await db.post.create({
+    data: {
+      title: String(formData.get('title')),
+      authorId: session.user.id,
+    },
+  })
+
+  revalidatePath('/posts')
+}
+```
+
+The mutation, the cache invalidation, and the page re-render all complete in a single roundtrip. Because [`redirect`](/docs/app/api-reference/functions/redirect#behavior) throws a control-flow exception, any code after it does not run. Place revalidation calls before `redirect` if the destination needs the fresh data.
+
+[`revalidateTag`](/docs/app/api-reference/functions/revalidateTag) with a stale-while-revalidate profile is the exception: it marks the tag for background refresh and does **not** include a re-render in the action response. The page reflects the change on a later read. An action that does none of the above carries only its return value, and the current route is not re-rendered.
+
+## Security
+
+A Server Action runs as a POST request against the page that invokes it. At build time, the `'use server'` directive tells the compiler to swap the function's implementation in client bundles for a reference (an action ID plus a dispatcher) that POSTs back to the server. The implementation stays on the server, but the route is reachable to anyone who can send the same POST. Treat every action as an untrusted entry point.
+
+Next.js enforces a few framework-level protections:
+
+- **CSRF check.** The request's `Origin` is compared to the `Host` (or `X-Forwarded-Host`). Mismatches are rejected. Configure [`serverActions.allowedOrigins`](/docs/app/api-reference/config/next-config-js/serverActions#allowedorigins) for proxy or CDN domains.
+- **Body size limit.** Action requests are capped at 1MB by default. Configure [`serverActions.bodySizeLimit`](/docs/app/api-reference/config/next-config-js/serverActions#bodysizelimit) when accepting larger payloads.
+- **Encrypted action IDs and dead code elimination.** Action references are encrypted at build time, and unused Server Functions are stripped from client bundles so they have no public endpoint. See [Built-in Server Actions security features](/docs/app/guides/data-security#built-in-server-actions-security-features).
+- **Closure variable encryption.** Variables captured by an inline action are encrypted before being sent to the client. For multi-instance and self-hosted deployments, set `NEXT_SERVER_ACTIONS_ENCRYPTION_KEY` to a stable key shared across instances. See [Closures and encryption](/docs/app/guides/data-security#closures-and-encryption).
+
+Framework protections are not a substitute for application-level checks. Inside every action:
+
+- **Authenticate and authorize.** Render-time gating (only rendering a form on an authenticated page) is not a security boundary, because requests can be sent without going through the UI.
+- **Validate inputs.** Treat `FormData`, query parameters, and headers as untrusted.
+- **Constrain return values.** Action returns are serialized to the client. Shape them to what the UI renders, not raw database records.
+
+For end-to-end patterns including a Data Access Layer, return-value tainting, and rate limiting, see the [Data Security guide](/docs/app/guides/data-security#mutating-data).
+
+Destructive operations like deletes may warrant stronger handling, such as elevated session checks or re-authentication, and a loud failure when those checks miss.
+
+```ts filename="app/posts/actions.ts" highlight={6,7,8}
+'use server'
+
+import { auth } from '@/lib/auth'
+
+export async function deletePost(postId: string) {
+  const session = await auth()
+  if (!session?.user) throw new Error('Unauthorized')
+  if (!(await canDelete(session.user, postId))) throw new Error('Forbidden')
+
+  await db.post.delete({ where: { id: postId } })
+}
+```
+
+If you've enabled the experimental [`authInterrupts`](/docs/app/api-reference/config/next-config-js/authInterrupts) flag, you can throw [`unauthorized()`](/docs/app/api-reference/functions/unauthorized) and [`forbidden()`](/docs/app/api-reference/functions/forbidden) from `next/navigation` instead, so Next.js renders the corresponding `unauthorized.tsx` / `forbidden.tsx` UI segment automatically.
+
+For example, a client legitimately tells the server _which_ item to act on, but it should not supply the row's contents or ownership. Send a reference (typically an ID) plus the user's change, and re-read the rest from a trusted source using the session. Schema validation (zod or similar) only checks the _shape_ of the input. A well-formed `Item` object can still refer to a row the caller does not own.
+
+```ts filename="app/items/actions.ts"
+'use server'
+
+import { auth } from '@/lib/auth'
+import { db } from '@/lib/db'
+
+// Unsafe: no auth, no ownership check. The whole item, including its id, comes
+// from the client, so anyone who can POST here can mark any item complete.
+export async function completeItemUnsafe(item: Item) {
+  await db.item.update({ where: { id: item.id }, data: { completed: true } })
+}
+
+// Safe: take only the change, derive identity from the session, look up by ownership.
+export async function completeItem(itemId: string) {
+  const session = await auth()
+  if (!session?.user) return
+
+  const item = await db.item.findFirst({
+    where: { id: itemId, ownerId: session.user.id },
+  })
+  if (!item) return
+
+  await db.item.update({ where: { id: item.id }, data: { completed: true } })
+}
+```
+
+## Choosing a cache update
+
+After mutating data, on-demand revalidation updates the server cache, the client router, or both. Choose based on what needs to change:
+
+- [`updateTag`](/docs/app/api-reference/functions/updateTag): immediate expiration of a tag. The next read (including the route re-render that ships with the action's response) waits for fresh data. Use when the action needs **read-your-own-writes** so the user immediately sees their change. Server Actions only.
+- [`revalidateTag`](/docs/app/api-reference/functions/revalidateTag): stale-while-revalidate refresh of a tag with a cache-life profile. Subsequent reads get the stale value while a fresh fetch happens in the background, so the action's own re-render does **not** wait for the new data.
+- [`revalidatePath`](/docs/app/api-reference/functions/revalidatePath): invalidate by URL path. Use when one route is affected and tagging is overkill.
+- [`refresh`](/docs/app/api-reference/functions/refresh): refetch the current route's RSC Payload without invalidating cached data. Use when the view depends on state outside the cache that the action just changed.
+
+When `updateTag`, `revalidatePath`, or `refresh` runs, Next.js re-renders the current route server-side and includes a newly rendered [RSC Payload](/docs/app/glossary#rsc-payload) in the action's response, so the page reflects the change in the same roundtrip. `revalidateTag` with a stale-while-revalidate profile intentionally skips that immediate re-render.
+
+Unlike [`redirect`](/docs/app/api-reference/functions/redirect), none of these throw, so an action can call them and still return a value to the caller. See [How revalidation works](/docs/app/guides/how-revalidation-works) for the underlying model.
+
+## Configuration
+
+The [`serverActions`](/docs/app/api-reference/config/next-config-js/serverActions) option in `next.config.js` controls framework-level behavior:
+
+```js filename="next.config.js"
+/** @type {import('next').NextConfig} */
+module.exports = {
+  experimental: {
+    serverActions: {
+      allowedOrigins: ['my-proxy.com', '*.my-proxy.com'],
+      bodySizeLimit: '2mb',
+    },
+  },
+}
+```
+
+For the closure encryption key, set `NEXT_SERVER_ACTIONS_ENCRYPTION_KEY` in the deployment environment. See [Self-hosting: Server Functions encryption key](/docs/app/guides/self-hosting#server-functions-encryption-key) for deployment-specific guidance.
+
+## Deployment considerations
+
+Each Server Action is identified by the [action ID](#security) that is part of its build artifacts. New deployments typically generate new IDs (Next.js rotates them at most every 14 days, even when the source is unchanged), so a client still running the previous build may invoke an action ID that no longer exists. The error surfaces as "[Failed to find Server Action](https://nextjs.org/docs/messages/failed-to-find-server-action)".
+
+To minimize disruption:
+
+- Prefer rolling deployments over abrupt cutovers when active users are likely to be mid-mutation.
+- Keep `NEXT_SERVER_ACTIONS_ENCRYPTION_KEY` stable across instances so action references remain decryptable everywhere.
+- Surface the error as a retry path in the UI rather than a hard failure, so a refresh recovers the user.

package/dist/docs/01-app/02-guides/streaming.md

@@ -383,7 +383,6 @@ Prefer explicit `<Suspense>` boundaries close to the dynamic access. When the pr
 
 ### Error handling mid-stream
 
-{/* TODO: catchError semantics - not landed on stable yet */}
 If a component throws an error after streaming has started, the nearest [`error.js`](/docs/app/api-reference/file-conventions/error) boundary catches it and renders the error UI in place of the failed component. The rest of the page remains intact, only the section that errored is replaced.
 
 Because the HTTP status code (`200 OK`) has already been sent with the first chunk, it cannot be changed to a `4xx` or `5xx`. The error is handled entirely within the streamed HTML. See [The HTTP contract](#the-http-contract) for more on this constraint.

package/dist/docs/01-app/02-guides/third-party-libraries.md

@@ -367,6 +367,7 @@ Options to pass to the `<GoogleAnalytics>` component.
 | --------------- | -------- | ------------------------------------------------------------------------------------------------------ |
 | `gaId`          | Required | Your [measurement ID](https://support.google.com/analytics/answer/12270356). Usually starts with `G-`. |
 | `dataLayerName` | Optional | Name of the data layer. Defaults to `dataLayer`.                                                       |
+| `debugMode`     | Optional | Enable Google Analytics [debug mode](https://support.google.com/analytics/answer/7201382).             |
 | `nonce`         | Optional | A [nonce](/docs/app/guides/content-security-policy#nonces).                                            |
 
 ### Google Maps Embed

package/dist/docs/01-app/02-guides/upgrading/version-15.md

@@ -374,7 +374,7 @@ export async function generateMetadata(props) {
   const query = searchParams.query
 }
 
-export async function Page(props) {
+export default async function Page(props) {
   const params = await props.params
   const searchParams = await props.searchParams
   const slug = params.slug

package/dist/docs/01-app/03-api-reference/01-directives/use-server.md

@@ -5,6 +5,8 @@ description: Learn how to use the use server directive to execute code on the se
 
 The `use server` directive designates a function or file to be executed on the **server side**. It can be used at the top of a file to indicate that all functions in the file are server-side, or inline at the top of a function to mark the function as a [Server Function](https://19.react.dev/reference/rsc/server-functions). This is a React feature.
 
+For Next.js-specific Server Action behaviors (response model, security, configuration, deployment), see [Server Actions and Mutations](/docs/app/guides/server-actions).
+
 ## Using `use server` at the top of a file
 
 The following example shows a file with a `use server` directive at the top. All functions in the file are executed on the server.

package/dist/docs/01-app/03-api-reference/03-file-conventions/dynamic-routes.md

@@ -1,7 +1,7 @@
 ---
 title: Dynamic Route Segments
 nav_title: Dynamic Segments
-description: Dynamic Route Segments can be used to programmatically generate route segments from dynamic data.
+description: Use Dynamic Segments to read URL path params and generate routes from dynamic data.
 related:
   title: Next Steps
   description: For more information on what to do next, we recommend the following sections
@@ -9,7 +9,9 @@ related:
     - app/api-reference/functions/generate-static-params
 ---
 
-When you don't know the exact route segment names ahead of time and want to create routes from dynamic data, you can use Dynamic Segments that are filled in at request time or prerendered at build time.
+A URL path is a sequence of path segments. In the App Router, a segment may be **static** (a literal value matched exactly) or **dynamic** (a placeholder that captures a value from the URL). When you don't know a segment's value ahead of time, define a Dynamic Segment to create routes from dynamic data. Next.js passes the captured values to your page via the path `params` prop, either filled in at request time or prerendered at build time.
+
+> **Good to know**: Dynamic Segments are often referred to as path params, route params, or URL params.
 
 ## Convention
 

package/dist/docs/01-app/03-api-reference/03-file-conventions/instrumentation.md

@@ -48,10 +48,17 @@ export const onRequestError: Instrumentation.onRequestError = async (
   request,
   context
 ) => {
+  const message = err instanceof Error ? err.message : String(err)
+  const digest =
+    typeof err === 'object' && err !== null && 'digest' in err
+      ? String(err.digest)
+      : undefined
+
   await fetch('https://.../report-error', {
     method: 'POST',
     body: JSON.stringify({
-      message: err.message,
+      message,
+      digest,
       request,
       context,
     }),
@@ -64,10 +71,17 @@ export const onRequestError: Instrumentation.onRequestError = async (
 
 ```js filename="instrumentation.js" switcher
 export async function onRequestError(err, request, context) {
+  const message = err instanceof Error ? err.message : String(err)
+  const digest =
+    typeof err === 'object' && err !== null && 'digest' in err
+      ? String(err.digest)
+      : undefined
+
   await fetch('https://.../report-error', {
     method: 'POST',
     body: JSON.stringify({
-      message: err.message,
+      message,
+      digest,
       request,
       context,
     }),
@@ -84,7 +98,7 @@ The function accepts three parameters: `error`, `request`, and `context`.
 
 ```ts filename="Types"
 export function onRequestError(
-  error: { digest: string } & Error,
+  error: unknown,
   request: {
     path: string // resource path, e.g. /blog?name=foo
     method: string // request method. e.g. GET, POST, etc
@@ -104,7 +118,7 @@ export function onRequestError(
 ): void | Promise<void>
 ```
 
-- `error`: The caught error itself (type is always `Error`), and a `digest` property which is the unique ID of the error.
+- `error`: The caught value is typed as `unknown`. Narrow it before reading properties like `message` or `digest`.
 - `request`: Read-only request information associated with the error.
 - `context`: The context in which the error occurred. This can be the type of router (App or Pages Router), and/or (Server Components (`'render'`), Route Handlers (`'route'`), Server Actions (`'action'`), or Proxy (`'proxy'`)).
 

package/dist/docs/01-app/03-api-reference/05-config/01-next-config-js/rewrites.md

@@ -91,10 +91,11 @@ The order Next.js routes are checked is:
 1. [headers](/docs/app/api-reference/config/next-config-js/headers) are checked/applied
 2. [redirects](/docs/app/api-reference/config/next-config-js/redirects) are checked/applied
 3. [proxy](/docs/app/api-reference/file-conventions/proxy)
-4. `beforeFiles` rewrites are checked/applied
+4. `beforeFiles` rewrites: for each entry, if `source`, `has`, and `missing` matches the request, it's rewritten to `destination`.
 5. static files from the [public directory](/docs/app/api-reference/file-conventions/public-folder), `_next/static` files, and non-dynamic pages are checked/served
-6. `afterFiles` rewrites are checked/applied, if one of these rewrites is matched we check dynamic routes/static files after each match
-7. `fallback` rewrites are checked/applied, these are applied before rendering the 404 page and after dynamic routes/all static assets have been checked. If you use [fallback: true/'blocking'](/docs/pages/api-reference/functions/get-static-paths#fallback-true) in `getStaticPaths`, the fallback `rewrites` defined in your `next.config.js` will _not_ be run.
+6. `afterFiles` rewrites are tried in order. If a `source`, `has`, and `missing` matches the request, it's rewritten to `destination`; the first rewrite that resolves to a static file, page, or dynamic route is served.
+7. dynamic routes (e.g., `app/blog/[slug]/page.tsx`) are matched against the current path
+8. `fallback` rewrites are checked/applied, these are applied before rendering the 404 page and after dynamic routes/all static assets have been checked. If you use [fallback: true/'blocking'](/docs/pages/api-reference/functions/get-static-paths#fallback-true) in `getStaticPaths`, those dynamic routes take priority over the fallback `rewrites` defined in your `next.config.js`.
 
 </AppOnly>
 
@@ -102,10 +103,11 @@ The order Next.js routes are checked is:
 
 1. [headers](/docs/pages/api-reference/config/next-config-js/headers) are checked/applied
 2. [redirects](/docs/pages/api-reference/config/next-config-js/redirects) are checked/applied
-3. `beforeFiles` rewrites are checked/applied
+3. `beforeFiles` rewrites: for each entry, if `source` matches the request, it's rewritten to `destination`.
 4. static files from the [public directory](/docs/pages/api-reference/file-conventions/public-folder), `_next/static` files, and non-dynamic pages are checked/served
-5. `afterFiles` rewrites are checked/applied, if one of these rewrites is matched we check dynamic routes/static files after each match
-6. `fallback` rewrites are checked/applied, these are applied before rendering the 404 page and after dynamic routes/all static assets have been checked. If you use [fallback: true/'blocking'](/docs/pages/api-reference/functions/get-static-paths#fallback-true) in `getStaticPaths`, the fallback `rewrites` defined in your `next.config.js` will _not_ be run.
+5. `afterFiles` rewrites are tried in order. If a `source` matches the request, it's rewritten to `destination`; the first rewrite that resolves to a static file, page, or dynamic route is served.
+6. dynamic routes (e.g., `pages/blog/[slug].tsx`) are matched against the current path
+7. `fallback` rewrites are checked/applied, these are applied before rendering the 404 page and after dynamic routes/all static assets have been checked. If you use [fallback: true/'blocking'](/docs/pages/api-reference/functions/get-static-paths#fallback-true) in `getStaticPaths`, the fallback `rewrites` defined in your `next.config.js` will _not_ be run.
 
 </PagesOnly>
 

package/dist/docs/01-app/03-api-reference/05-config/01-next-config-js/serverActions.md

@@ -39,6 +39,8 @@ module.exports = {
 }
 ```
 
+The limit applies to the raw HTTP request body, including the bytes that `multipart/form-data` adds for boundaries, part headers, and field metadata. If you expect uploads close to the configured value, leave some room for this overhead. For typical multipart uploads, an additional 10–20 KB is a reasonable rule of thumb.
+
 ## Enabling Server Actions (v13)
 
 Server Actions became a stable feature in Next.js 14, and are enabled by default. However, if you are using an earlier version of Next.js, you can enable them by setting `experimental.serverActions` to `true`.

package/dist/docs/01-app/03-api-reference/05-config/01-next-config-js/transpilePackages.md

@@ -1,21 +1,33 @@
 ---
 title: transpilePackages
-description: Automatically transpile and bundle dependencies from local packages (like monorepos) or from external dependencies (`node_modules`).
+description: Transpile and bundle dependencies from monorepo workspace packages or `node_modules` libraries that ship TypeScript, JSX, or modern syntax.
 ---
 
 {/* The content of this doc is shared between the app and pages router. You can use the `<PagesOnly>Content</PagesOnly>` component to add content that is specific to the Pages Router. Any shared content should not be wrapped in a component. */}
 
-Next.js can automatically transpile and bundle dependencies from local packages (like monorepos) or from external dependencies (`node_modules`). This replaces the `next-transpile-modules` package.
+Use `transpilePackages` to compile and bundle a dependency instead of treating it as untouched runtime code. Values are package names, including scoped names like `@scope/pkg`. Paths and glob patterns are not supported.
 
 ```js filename="next.config.js"
 /** @type {import('next').NextConfig} */
 const nextConfig = {
-  transpilePackages: ['package-name'],
+  transpilePackages: ['package-name', '@scope/pkg'],
 }
 
 module.exports = nextConfig
 ```
 
+This replaces the `next-transpile-modules` package.
+
+## When you need it
+
+Turbopack transpiles workspace packages (npm, pnpm, or Yarn workspaces) in your monorepo automatically under both routers. Webpack does the same for the App Router. Add a package to `transpilePackages` when:
+
+- **A `node_modules` dependency ships raw TypeScript or JSX.** Next.js does not compile code inside `node_modules` by default. Listing the package opts it in, or you can build the package to plain JavaScript and point its `main`/`exports` at the compiled output.
+- **You build with webpack for the Pages Router and the dependency's source lives outside the next app's directory.** For example, an `apps/web` app importing `packages/ui` in the same monorepo.
+- **You use the Pages Router and want a `node_modules` dependency bundled into the route.** Pages Router loads `node_modules` server-side dependencies through Node.js `require` at runtime. List the package to bundle its source into the route instead. App Router already bundles Server Component and Route Handler dependencies unless the package is listed in [`serverExternalPackages`](/docs/app/api-reference/config/next-config-js/serverExternalPackages).
+
+> **Good to know**: A package cannot appear in both `transpilePackages` and [`serverExternalPackages`](/docs/app/api-reference/config/next-config-js/serverExternalPackages); Next.js throws at build start if it does. Packages listed in [`optimizePackageImports`](/docs/app/api-reference/config/next-config-js/optimizePackageImports) and the entries in [`default-transpiled-packages.json`](https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/default-transpiled-packages.json) are added automatically; you do not need to repeat them.
+
 ## Version History
 
 | Version   | Changes                    |

package/dist/docs/01-app/03-api-reference/05-config/02-typescript.md

@@ -88,7 +88,7 @@ Running `next dev`, `next build`, or [`next typegen`](/docs/app/api-reference/cl
 
 > **Good to know**:
 >
-> - We recommend adding `next-env.d.ts` to your `.gitignore` file.
+> - `next-env.d.ts` is managed by Next.js. Its contents are an implementation detail and may change over time. Add it to `.gitignore`. If your project already tracks the file, remove it from Git. Do not edit this file manually.
 > - The file must be in your `tsconfig.json` `include` array (`create-next-app` does this automatically).
 
 ## Examples

package/dist/docs/01-app/04-glossary.md

@@ -223,7 +223,7 @@ The default component type in the App Router. Server Components render on the se
 
 ## Server Action
 
-A [Server Function](#server-function) that is passed to a Client Component as a prop or bound to a form action. Server Actions are commonly used for form submissions and data mutations. Learn more in [Server Actions and Mutations](/docs/app/getting-started/mutating-data).
+A [Server Function](#server-function) that is passed to a Client Component as a prop or bound to a form action. Server Actions are commonly used for form submissions and data mutations. Learn more in [Server Actions and Mutations](/docs/app/guides/server-actions).
 
 ## Server Function
 

package/dist/docs/02-pages/02-guides/upgrading/version-12.md

@@ -50,7 +50,7 @@ Next.js now uses the Rust-based compiler [SWC](https://swc.rs/) to compile JavaS
 
 Next.js provides full backward compatibility with applications that have [custom Babel configuration](/docs/pages/guides/babel). All transformations that Next.js handles by default like styled-jsx and tree-shaking of `getStaticProps` / `getStaticPaths` / `getServerSideProps` have been ported to Rust.
 
-When an application has a custom Babel configuration, Next.js will automatically opt-out of using SWC for compiling JavaScript/Typescript and will fall back to using Babel in the same way that it was used in Next.js 11.
+When an application has a custom Babel configuration, Next.js will automatically opt-out of using SWC for compiling JavaScript/TypeScript and will fall back to using Babel in the same way that it was used in Next.js 11.
 
 Many of the integrations with external libraries that currently require custom Babel transformations will be ported to Rust-based SWC transforms in the near future. These include but are not limited to:
 

package/dist/docs/04-community/01-contribution-guide.md

@@ -34,7 +34,7 @@ The docs are written in [MDX](https://mdxjs.com/), a markdown format that suppor
 
 VSCode has a built-in markdown previewer that you can use to see your edits locally. To enable the previewer for MDX files, you'll need to add a configuration option to your user settings.
 
-Open the command palette (`⌘ + ⇧ + P` on Mac or `Ctrl + Shift + P` on Windows) and search from `Preferences: Open User Settings (JSON)`.
+Open the command palette (`⌘ + ⇧ + P` on Mac or `Ctrl + Shift + P` on Windows) and search for `Preferences: Open User Settings (JSON)`.
 
 Then, add the following line to your `settings.json` file:
 
@@ -396,7 +396,7 @@ While we don't have a strict template for pages, there are page sections you'll
 - **Overview:** The first paragraph of a page should tell the user what the feature is and what it's used for. Followed by a minimum working example or its API reference.
 - **Convention:** If the feature has a convention, it should be explained here.
 - **Examples**: Show how the feature can be used with different use cases.
-- **API Tables**: API Pages should have an overview table at the of the page with jump-to-section links (when possible).
+- **API Tables**: API Pages should have an overview table at the top of the page with jump-to-section links (when possible).
 - **Next Steps (Related Links)**: Add links to related pages to guide the user's learning journey.
 
 Feel free to add these sections as needed.

package/dist/docs/index.md

@@ -8,8 +8,6 @@ related:
     - app/getting-started
 ---
 
-{/* AI agent hint: If fixing slow client-side navigations, Suspense alone is not enough. You must also export `unstable_instant` from the route. Read docs/01-app/02-guides/instant-navigation.mdx before making changes. */}
-
 Welcome to the Next.js documentation!
 
 ## What is Next.js?

package/dist/esm/build/index.js

@@ -333,7 +333,7 @@ export default async function build(dir, experimentalAnalyze = false, reactProdu
     try {
         const nextBuildSpan = trace('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "16.2.9",
+            version: "16.2.10",
             ...enabledFeatures
         });
         NextBuildContext.nextBuildSpan = nextBuildSpan;
@@ -769,7 +769,7 @@ export default async function build(dir, experimentalAnalyze = false, reactProdu
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(path.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await recordFrameworkVersion("16.2.9");
+            await recordFrameworkVersion("16.2.10");
             await updateBuildDiagnostics({
                 buildStage: 'start'
             });
@@ -2497,7 +2497,7 @@ export default async function build(dir, experimentalAnalyze = false, reactProdu
                         configOutDir: path.join(dir, configOutDir),
                         staticPages,
                         serverPropsPages,
-                        nextVersion: "16.2.9",
+                        nextVersion: "16.2.10",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,

package/dist/esm/build/swc/index.js

@@ -10,7 +10,7 @@ export var HmrTarget = /*#__PURE__*/ function(HmrTarget) {
     HmrTarget["Server"] = "server";
     return HmrTarget;
 }({});
-const nextVersion = "16.2.9";
+const nextVersion = "16.2.10";
 const ArchName = arch();
 const PlatformName = platform();
 function infoLog(...args) {

package/dist/esm/build/turbopack-analyze/index.js

@@ -66,7 +66,7 @@ export async function turbopackAnalyze(analyzeContext) {
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: persistentCaching,
-        nextVersion: "16.2.9"
+        nextVersion: "16.2.10"
     }, {
         memoryLimit: (_config_experimental2 = config.experimental) == null ? void 0 : _config_experimental2.turbopackMemoryLimit,
         dependencyTracking: persistentCaching,

package/dist/esm/build/turbopack-build/impl.js

@@ -83,7 +83,7 @@ export async function turbopackBuild() {
         currentNodeJsVersion,
         isPersistentCachingEnabled: persistentCaching,
         deferredEntries: config.experimental.deferredEntries,
-        nextVersion: "16.2.9"
+        nextVersion: "16.2.10"
     };
     const sharedTurboOptions = {
         memoryLimit: (_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.turbopackMemoryLimit,

package/dist/esm/build/webpack-config.js

@@ -1630,7 +1630,7 @@ export default async function getBaseWebpackConfig(dir, { buildId, encryptionKey
             isClient && new CopyFilePlugin({
                 // file path to build output of `@next/polyfill-nomodule`
                 filePath: require.resolve('./polyfills/polyfill-nomodule'),
-                cacheKey: "16.2.9",
+                cacheKey: "16.2.10",
                 name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
                 minimize: false,
                 info: {
@@ -1824,7 +1824,7 @@ export default async function getBaseWebpackConfig(dir, { buildId, encryptionKey
         //  - Next.js location on disk (some loaders use absolute paths and some resolve options depend on absolute paths)
         //  - Next.js version
         //  - next.config.js keys that affect compilation
-        version: `${__dirname}|${"16.2.9"}|${configVars}`,
+        version: `${__dirname}|${"16.2.10"}|${configVars}`,
         cacheDirectory: path.join(distDir, 'cache', 'webpack'),
         // For production builds, it's more efficient to compress all cache files together instead of compression each one individually.
         // So we disable compression here and allow the build runner to take care of compressing the cache as a whole.
@@ -1880,7 +1880,7 @@ export default async function getBaseWebpackConfig(dir, { buildId, encryptionKey
                 type: 'filesystem',
                 directory: cache.cacheDirectory
             },
-            version: `${__dirname}|${"16.2.9"}|${configVars}`
+            version: `${__dirname}|${"16.2.10"}|${configVars}`
         };
     }
     if (process.env.NEXT_WEBPACK_LOGGING) {

package/dist/esm/client/app-bootstrap.js

@@ -5,7 +5,7 @@
  * - next/script with `beforeInteractive` strategy
  */ import { getAssetPrefix } from './asset-prefix';
 import { setAttributesFromProps } from './set-attributes-from-props';
-const version = "16.2.9";
+const version = "16.2.10";
 window.next = {
     version,
     appDir: true

package/dist/esm/client/index.js

@@ -25,7 +25,7 @@ import { SearchParamsContext, PathParamsContext } from '../shared/lib/hooks-clie
 import { onRecoverableError } from './react-client-callbacks/on-recoverable-error';
 import tracer from './tracing/tracer';
 import { isNextRouterError } from './components/is-next-router-error';
-export const version = "16.2.9";
+export const version = "16.2.10";
 export let router;
 export const emitter = mitt();
 const looseToArray = (input)=>[].slice.call(input);

package/dist/esm/lib/patch-incorrect-lockfile.js

@@ -17,7 +17,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.2.9"];
+    const versionData = data.versions["16.2.10"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -50,7 +50,7 @@ async function fetchPkgInfo(pkg) {
     const expectedSwcPkgs = Object.keys(nextOptionalDeps || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.2.9",
+            version: "16.2.10",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -58,7 +58,7 @@ async function fetchPkgInfo(pkg) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.2.9",
+            version: "16.2.10",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/dist/esm/server/config.js

@@ -1032,7 +1032,7 @@ async function applyModifyConfig(config, phase, silent) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.2.9"
+                nextVersion: "16.2.10"
             });
         }
     }

package/dist/esm/server/dev/hot-reloader-turbopack.js

@@ -184,7 +184,7 @@ export async function createHotReloaderTurbopack(opts, serverFields, distDir, re
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = trace('hot-reloader', undefined, {
-        version: "16.2.9"
+        version: "16.2.10"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -238,7 +238,7 @@ export async function createHotReloaderTurbopack(opts, serverFields, distDir, re
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: isFileSystemCacheEnabledForDev(opts.nextConfig),
-        nextVersion: "16.2.9",
+        nextVersion: "16.2.10",
         serverHmr: serverFastRefresh
     }, {
         memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,

package/dist/esm/server/dev/hot-reloader-webpack.js

@@ -166,7 +166,7 @@ export default class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = trace('hot-reloader', undefined, {
-            version: "16.2.9"
+            version: "16.2.10"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.