diff --git a/docs/01-app/02-guides/videos.mdx b/docs/01-app/02-guides/videos.mdx
index c745ec1127ca..90fb15c52250 100644
--- a/docs/01-app/02-guides/videos.mdx
+++ b/docs/01-app/02-guides/videos.mdx
@@ -17,7 +17,13 @@ The HTML [`<video>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/v
 ```jsx filename="app/ui/video.jsx"
 export function Video() {
   return (
-    <video width="320" height="240" controls preload="none">
+    <video
+      width="320"
+      height="240"
+      poster="/path/to/poster.jpg"
+      controls
+      preload="none"
+    >
       <source src="/path/to/video.mp4" type="video/mp4" />
       <track
         src="/path/to/captions.vtt"
@@ -42,6 +48,7 @@ export function Video() {
 | `autoPlay`    | Automatically starts playing the video when the page loads. Note: Autoplay policies vary across browsers. | `<video autoPlay />`                 |
 | `loop`        | Loops the video playback.                                                                                 | `<video loop />`                     |
 | `muted`       | Mutes the audio by default. Often used with `autoPlay`.                                                   | `<video muted />`                    |
+| `poster`      | An image shown in the video's box until the first frame is available.                                     | `<video poster="/poster.jpg" />`     |
 | `preload`     | Specifies how the video is preloaded. Values: `none`, `metadata`, `auto`.                                 | `<video preload="none" />`           |
 | `playsInline` | Enables inline playback on iOS devices, often necessary for autoplay to work on iOS Safari.               | `<video playsInline />`              |
 
@@ -51,6 +58,8 @@ For a comprehensive list of video attributes, refer to the [MDN documentation](h
 
 ### Video best practices
 
+- **Dimensions:** Set `width` and `height`, or a CSS `aspect-ratio`, so the browser reserves the box before the file loads. A video without dimensions collapses and then pushes the rest of the page down, which counts against [Cumulative Layout Shift](https://web.dev/articles/cls).
+- **Poster Image:** Use `poster` to fill that reserved box while the video loads, especially with `preload="none"`, where no frame is fetched until playback starts.
 - **Fallback Content:** When using the `<video>` tag, include fallback content inside the tag for browsers that do not support video playback.
 - **Subtitles or Captions:** Include subtitles or captions for users who are deaf or hard of hearing. Utilize the [`<track>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/track) tag with your `<video>` elements to specify caption file sources.
 - **Accessible Controls:** Standard HTML5 video controls are recommended for keyboard navigation and screen reader compatibility. For advanced needs, consider third-party players like [react-player](https://github.com/cookpete/react-player) or [video.js](https://videojs.com/), which offer accessible controls and consistent browser experience.
@@ -77,8 +86,11 @@ export default function Page() {
 | `allowFullScreen` | Allows the iframe content to be displayed in full-screen mode.         | `<iframe allowFullScreen />`           |
 | `sandbox`         | Enables an extra set of restrictions on the content within the iframe. | `<iframe sandbox />`                   |
 | `loading`         | Optimize loading behavior (e.g., lazy loading).                        | `<iframe loading="lazy" />`            |
+| `style`           | Apply CSS, such as an `aspect-ratio` to keep the box a fixed shape.    | `<iframe style={{ border: 0 }} />`     |
 | `title`           | Provides a title for the iframe to support accessibility.              | `<iframe title="Description" />`       |
 
+An iframe without dimensions collapses until its content loads, the same as a video. Give it `width` and `height` or an `aspect-ratio`, particularly with `loading="lazy"`, where the embed can resolve long after the surrounding page has painted.
+
 For a comprehensive list of iframe attributes, refer to the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attributes).
 
 ### Choosing a video embedding method
diff --git a/docs/01-app/03-api-reference/05-config/01-next-config-js/cacheHandlers.mdx b/docs/01-app/03-api-reference/05-config/01-next-config-js/cacheHandlers.mdx
index ff11a1617932..2620c8343aeb 100644
--- a/docs/01-app/03-api-reference/05-config/01-next-config-js/cacheHandlers.mdx
+++ b/docs/01-app/03-api-reference/05-config/01-next-config-js/cacheHandlers.mdx
@@ -69,47 +69,53 @@ You can also define additional named handlers (e.g., `sessions`, `analytics`) an
 
 Note that `'use cache: private'` does not use cache handlers and cannot be customized.
 
-## API Reference
+## CacheEntry Type
 
-A cache handler must implement the `CacheHandler` interface with the following methods. The `CacheHandler` and `CacheEntry` types are exported from `next/cache`:
+A cache handler stores and returns `CacheEntry` objects. Both this type and `CacheHandler` are exported from `next/cache`:
 
 ```ts
 import type { CacheHandler, CacheEntry } from 'next/cache'
 ```
 
-### `get()`
-
-Retrieve a cache entry for the given cache key.
+An entry has the following structure:
 
 ```ts
-get(cacheKey: string, softTags: string[]): Promise<CacheEntry | undefined>
+interface CacheEntry {
+  value: ReadableStream<Uint8Array>
+  tags: string[]
+  stale: number
+  timestamp: number
+  expire: number
+  revalidate: number
+}
 ```
 
-| Parameter  | Type       | Description                                                                                 |
-| ---------- | ---------- | ------------------------------------------------------------------------------------------- |
-| `cacheKey` | `string`   | The unique key for the cache entry.                                                         |
-| `softTags` | `string[]` | Implicit tags derived from the route path. See [Soft Tags](#soft-tags) for how to use them. |
+| Property     | Type                         | Description                                                  |
+| ------------ | ---------------------------- | ------------------------------------------------------------ |
+| `value`      | `ReadableStream<Uint8Array>` | The cached data as a single-use stream.                      |
+| `tags`       | `string[]`                   | Cache tags (excluding soft tags).                            |
+| `stale`      | `number`                     | Duration in seconds for client-side staleness.               |
+| `timestamp`  | `number`                     | When the entry was created (timestamp in milliseconds).      |
+| `expire`     | `number`                     | How long the entry is allowed to be used (in seconds).       |
+| `revalidate` | `number`                     | How long until the entry should be revalidated (in seconds). |
 
-Returns a `CacheEntry` object if found, or `undefined` if not found or expired.
+## The entry value stream
 
-Your `get` method should retrieve the cache entry from storage, check if it has expired based on the `revalidate` time, and return `undefined` for missing or expired entries.
+Every handler writes entries through [`set()`](#set) and serves them through [`get()`](#get). Both methods work with the entry's serialized value, which arrives as a [`ReadableStream<Uint8Array>`](https://developer.mozilla.org/docs/Web/API/ReadableStream). Two properties of that stream constrain every implementation:
 
-```js
-const cacheHandler = {
-  async get(cacheKey, softTags) {
-    const entry = cache.get(cacheKey)
-    if (!entry) return undefined
+- **It can be read only once.** Consume it in [`set()`](#set), and build a new stream over your stored data in every [`get()`](#get). A stream that was already read cannot serve a second reader: it delivers no data, or throws if the first reader still holds its lock.
+- **It belongs to the request that produced the entry.** Do not keep it once `set()` resolves. The stream holds a reference to that request, so keeping it holds the request's memory until your entry is evicted. The same applies to the `pendingEntry` promise. Next.js keeps its own copy of the value for the render, so your handler is free to consume the stream it receives.
 
-    // Check if expired
-    const now = Date.now()
-    if (now > entry.timestamp + entry.revalidate * 1000) {
-      return undefined
-    }
+How you persist the data is up to you. Buffering the stream and piping it to your store as chunks arrive are both fine, as long as you consume it exactly once. Large entries are worth piping: a page can serialize to a lot of bytes, and an S3-like backend can accept them without your handler holding a second copy.
 
-    return entry
-  },
-}
-```
+Two more cases to plan for:
+
+- **Fan-out.** If a single entry has to reach two destinations, such as a local store and a remote one, use [`.tee()`](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee) and consume both branches before `set()` resolves. Teeing is not a way to keep the value around. A stored branch does serve the next read, but it holds the source stream, its buffered chunks, and the request that produced them, and none of that appears in the size your store accounts for.
+- **Interrupted values.** The stream can error partway through rendering, which leaves you holding an incomplete value. Decide whether to keep it or discard it. Discarding is safer, because an incomplete value produces an incomplete page. This is separate from a partially written storage entry, which [Error Handling](#error-handling) covers.
+
+## API Reference
+
+A cache handler must implement the `CacheHandler` interface with the following five methods.
 
 ### `set()`
 
@@ -124,11 +130,11 @@ set(cacheKey: string, pendingEntry: Promise<CacheEntry>): Promise<void>
 | `cacheKey`     | `string`              | The unique key to store the entry under.    |
 | `pendingEntry` | `Promise<CacheEntry>` | A promise that resolves to the cache entry. |
 
-The entry may still be pending when this is called (i.e., its value stream may still be written to). Your handler should await the promise before processing the entry.
-
 Returns `Promise<void>`.
 
-Your `set` method must await the `pendingEntry` promise before storing it, since the cache entry may still be generating when this method is called. Once resolved, store the entry in your cache system.
+The entry may still be generating when `set()` is called, so await `pendingEntry` first. Then consume the value stream and persist what it delivers, as described in [The entry value stream](#the-entry-value-stream).
+
+The example below buffers, which is the simpler option and the right one for an in-memory store. A remote handler can pipe `entry.value` into an upload instead.
 
 ```js
 const cacheHandler = {
@@ -136,25 +142,84 @@ const cacheHandler = {
     // Wait for the entry to be ready
     const entry = await pendingEntry
 
+    // Consume the stream, then keep the data rather than the stream
+    const value = new Uint8Array(await new Response(entry.value).arrayBuffer())
+
     // Store in your cache system
-    cache.set(cacheKey, entry)
+    cache.set(cacheKey, { ...entry, value })
+  },
+}
+```
+
+### `get()`
+
+Retrieve a cache entry for the given cache key.
+
+```ts
+get(cacheKey: string, softTags: string[]): Promise<CacheEntry | undefined>
+```
+
+| Parameter  | Type       | Description                                                                                 |
+| ---------- | ---------- | ------------------------------------------------------------------------------------------- |
+| `cacheKey` | `string`   | The unique key for the cache entry.                                                         |
+| `softTags` | `string[]` | Implicit tags derived from the route path. See [Soft Tags](#soft-tags) for how to use them. |
+
+Returns a `CacheEntry` object if one is stored, or `undefined` if not.
+
+Your `get` method should retrieve the cache entry from storage and return `undefined` when there is nothing stored.
+
+You do not need to check how old the entry is. Next.js compares `timestamp` against the entry's own `expire` on every read and treats a too-old entry as a miss. It applies the same check to `revalidate` when the result is about to be written into another server cache, and it keeps entries a little longer on the dev server so reloads stay fast. Your own age check only duplicates the first of those.
+
+What the two timings mean for you is what Next.js does with the entry you return:
+
+- Past **`expire`**, the entry is discarded and the value is regenerated.
+- Past **`revalidate`** but within `expire`, the entry is served and a fresh one is generated in the background.
+
+Dropping entries earlier is a policy choice rather than a requirement. The [built-in handler](https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/cache-handlers/default.ts) drops at `revalidate` because warming a replacement is wasted work when an in-memory entry is likely to be evicted before anything reads it. A shared store has no such problem and can serve until `expire`.
+
+Eviction is yours, though. Next.js never deletes from your store, so use a mechanism that reclaims entries nobody reads again: a TTL derived from `expire`, or a size-bounded LRU like the one in the built-in handler. Checking the age of an entry as you serve it is not eviction, because it only ever reaches the keys that are still being read.
+
+Invalidation is separate from both timings. When a tag tells you an entry is out of date, you have two options:
+
+- Return `undefined`. The entry counts as missing, and Next.js regenerates it now.
+- Return the entry with `revalidate: -1`. Next.js serves it and regenerates in the background, because a negative `revalidate` always lies in the past.
+
+See [Soft Tags](#soft-tags) and [Distributed Tag Coordination](#distributed-tag-coordination) for where those invalidations come from.
+
+Wrap your stored data in a new stream on every hit, never the stream you received in `set()`.
+
+```js
+const cacheHandler = {
+  async get(cacheKey, softTags) {
+    const entry = cache.get(cacheKey)
+    if (!entry) return undefined
+
+    // No age check: Next.js compares `timestamp` against `expire` itself.
+    // `entry.value` holds the stored bytes, so wrap them in a fresh stream
+    return {
+      ...entry,
+      value: new ReadableStream({
+        start(controller) {
+          controller.enqueue(entry.value)
+          controller.close()
+        },
+      }),
+    }
   },
 }
 ```
 
 ### `refreshTags()`
 
-Called periodically before starting a new request to sync with external tag services.
+Called once per request, before the first cache read for this handler's kind, so the handler can sync tag state from an external service.
 
 ```ts
 refreshTags(): Promise<void>
 ```
 
-This is useful if you're coordinating cache invalidation across multiple instances or services. For in-memory caches, this can be a no-op.
-
 Returns `Promise<void>`.
 
-For in-memory caches, this can be a no-op. For distributed caches, use this to sync tag state from an external service or database before processing requests.
+For in-memory caches, this can be a no-op. For distributed caches, use it to read tag state from an external service or database, so this instance learns about invalidations made by the others before it serves anything from its own store. A request that reads nothing from this handler never calls it.
 
 ```js
 const cacheHandler = {
@@ -229,34 +294,79 @@ const cacheHandler = {
 }
 ```
 
-## CacheEntry Type
+## Soft Tags
 
-The `CacheEntry` object (exported from `next/cache`) has the following structure:
+Soft tags are implicit tags that Next.js automatically generates based on the route path. Every segment in the path gets a layout tag, plus the leaf route itself. For example, the route `/blog/hello` generates soft tags for `/layout`, `/blog/layout`, `/blog/hello/layout`, and `/blog/hello`. These tags are prefixed internally with `_N_T_`.
 
-```ts
-interface CacheEntry {
-  value: ReadableStream<Uint8Array>
-  tags: string[]
-  stale: number
-  timestamp: number
-  expire: number
-  revalidate: number
+Soft tags enable [`revalidatePath()`](/docs/app/api-reference/functions/revalidatePath) to work through the same tag-based cache system. When `revalidatePath('/blog/hello')` is called, it invalidates all cache entries associated with that path's soft tags.
+
+In the cache handler API, soft tags are passed to the [`get()`](#get) method as the `softTags` parameter. Your handler should check whether any soft tag has been invalidated (via `getExpiration()` or direct timestamp comparison) after the cache entry's `timestamp`.
+
+If an invalidation is more recent than the entry, report the entry as out of date using either option described in [`get()`](#get). The built-in handler uses both: it returns `undefined` for an expired tag, and `revalidate: -1` for a stale one.
+
+## Distributed Tag Coordination
+
+When running multiple Next.js instances, tag invalidation must be coordinated across instances. The default in-memory handler only tracks tags locally, so calling `revalidateTag()` on one instance does not affect others.
+
+To coordinate tags across instances:
+
+1. **`updateTags()`** is called when `revalidateTag()` is invoked. Your handler should write the invalidation timestamp to shared storage.
+2. **`refreshTags()`** runs once per request, before the first read from this handler. Your handler should read recent invalidation events from shared storage and update its local tag state.
+3. **`getExpiration()`** returns the most recent revalidation timestamp across all provided tags. The default implementation returns `Math.max(...timestamps, 0)`.
+
+Here's an example using Redis for distributed tag coordination:
+
+```js filename="cache-handlers/distributed-tags.js"
+const { createClient } = require('redis')
+
+const client = createClient({ url: process.env.REDIS_URL })
+client.connect()
+
+// Local cache of tag timestamps, synced via refreshTags
+const localTagTimestamps = new Map()
+
+module.exports = {
+  // ... get() and set() methods ...
+
+  async refreshTags() {
+    // Sync tag invalidation timestamps from Redis
+    // Using a dedicated set to track tag keys avoids scanning the keyspace
+    const tagKeys = await client.sMembers('revalidated-tags')
+    if (tagKeys.length > 0) {
+      const values = await client.mGet(tagKeys.map((k) => `tag:${k}`))
+      for (let i = 0; i < tagKeys.length; i++) {
+        localTagTimestamps.set(tagKeys[i], Number(values[i]))
+      }
+    }
+  },
+
+  async getExpiration(tags) {
+    const timestamps = tags.map((tag) => localTagTimestamps.get(tag) || 0)
+    return Math.max(...timestamps, 0)
+  },
+
+  async updateTags(tags, durations) {
+    const now = Date.now()
+    const pipeline = client.multi()
+    for (const tag of tags) {
+      pipeline.set(`tag:${tag}`, String(now))
+      pipeline.sAdd('revalidated-tags', tag)
+      localTagTimestamps.set(tag, now)
+    }
+    await pipeline.exec()
+  },
 }
 ```
 
-| Property     | Type                         | Description                                                  |
-| ------------ | ---------------------------- | ------------------------------------------------------------ |
-| `value`      | `ReadableStream<Uint8Array>` | The cached data as a stream.                                 |
-| `tags`       | `string[]`                   | Cache tags (excluding soft tags).                            |
-| `stale`      | `number`                     | Duration in seconds for client-side staleness.               |
-| `timestamp`  | `number`                     | When the entry was created (timestamp in milliseconds).      |
-| `expire`     | `number`                     | How long the entry is allowed to be used (in seconds).       |
-| `revalidate` | `number`                     | How long until the entry should be revalidated (in seconds). |
+For a full explanation of the tag architecture (including soft tags and multi-instance considerations), see [How Revalidation Works](/docs/app/guides/how-revalidation-works).
 
-> **Good to know**:
->
-> - The `value` is a [`ReadableStream`](https://developer.mozilla.org/docs/Web/API/ReadableStream). Use [`.tee()`](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee) if you need to read and store the stream data.
-> - If the stream errors with partial data, your handler must decide whether to keep the partial cache or discard it.
+## Error Handling
+
+Cache operations should be implemented defensively:
+
+- **`set()` failure**: the response is still served to the user because `set()` is called asynchronously after the response stream is already flowing. The cache entry is lost, and the next request triggers a fresh render. Catch your own errors even so: a rejected `set()` joins the request's pending revalidation work, where it surfaces as a failed background task instead of a render error.
+- **`get()` failure**: your handler should catch internal errors and return `undefined` (the "cache miss" signal). The framework does not wrap `get()` in a try/catch, so an unhandled exception from `get()` will propagate as a render error.
+- **Partial writes**: if a cache entry is partially written and then read, the behavior is undefined. Use atomic writes or a write-then-rename pattern to avoid serving partial entries.
 
 ## Examples
 
@@ -265,9 +375,19 @@ interface CacheEntry {
 Here's a minimal implementation using a `Map` for storage. This example demonstrates the core concepts, but for a production-ready implementation with LRU eviction, error handling, and tag management, see the [default cache handler](https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/cache-handlers/default.ts).
 
 ```js filename="cache-handlers/memory-handler.js"
+// Entries hold the serialized bytes, never the stream they arrived on
 const cache = new Map()
 const pendingSets = new Map()
 
+function streamFromBytes(bytes) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes)
+      controller.close()
+    },
+  })
+}
+
 module.exports = {
   async get(cacheKey, softTags) {
     // Wait for any pending set operation to complete
@@ -281,13 +401,11 @@ module.exports = {
       return undefined
     }
 
-    // Check if entry has expired
-    const now = Date.now()
-    if (now > entry.timestamp + entry.revalidate * 1000) {
-      return undefined
-    }
+    // No age check: Next.js compares `timestamp` against `expire` itself.
+    // This `Map` also has no eviction, which a real handler needs.
 
-    return entry
+    // Every hit gets its own stream over the stored bytes
+    return { ...entry, value: streamFromBytes(entry.value) }
   },
 
   async set(cacheKey, pendingEntry) {
@@ -302,8 +420,13 @@ module.exports = {
       // Wait for the entry to be ready
       const entry = await pendingEntry
 
-      // Store the entry in the cache
-      cache.set(cacheKey, entry)
+      // An in-memory store buffers the stream. Storing the stream itself, or
+      // a branch of it, keeps the request that produced the entry alive.
+      const value = new Uint8Array(
+        await new Response(entry.value).arrayBuffer()
+      )
+
+      cache.set(cacheKey, { ...entry, value })
     } finally {
       resolvePending()
       pendingSets.delete(cacheKey)
@@ -417,86 +540,6 @@ module.exports = {
 }
 ```
 
-## Distributed Tag Coordination
-
-When running multiple Next.js instances, tag invalidation must be coordinated across instances. The default in-memory handler only tracks tags locally, so calling `revalidateTag()` on one instance does not affect others.
-
-To coordinate tags across instances:
-
-1. **`updateTags()`** is called when `revalidateTag()` is invoked. Your handler should write the invalidation timestamp to shared storage.
-2. **`refreshTags()`** is called before each request. Your handler should read recent invalidation events from shared storage and update its local tag state.
-3. **`getExpiration()`** returns the most recent revalidation timestamp across all provided tags. The default implementation returns `Math.max(...timestamps, 0)`.
-
-Here's an example using Redis for distributed tag coordination:
-
-```js filename="cache-handlers/distributed-tags.js"
-const { createClient } = require('redis')
-
-const client = createClient({ url: process.env.REDIS_URL })
-client.connect()
-
-// Local cache of tag timestamps, synced via refreshTags
-const localTagTimestamps = new Map()
-
-module.exports = {
-  // ... get() and set() methods ...
-
-  async refreshTags() {
-    // Sync tag invalidation timestamps from Redis
-    // Using a dedicated set to track tag keys avoids scanning the keyspace
-    const tagKeys = await client.sMembers('revalidated-tags')
-    if (tagKeys.length > 0) {
-      const values = await client.mGet(tagKeys.map((k) => `tag:${k}`))
-      for (let i = 0; i < tagKeys.length; i++) {
-        localTagTimestamps.set(tagKeys[i], Number(values[i]))
-      }
-    }
-  },
-
-  async getExpiration(tags) {
-    const timestamps = tags.map((tag) => localTagTimestamps.get(tag) || 0)
-    return Math.max(...timestamps, 0)
-  },
-
-  async updateTags(tags, durations) {
-    const now = Date.now()
-    const pipeline = client.multi()
-    for (const tag of tags) {
-      pipeline.set(`tag:${tag}`, String(now))
-      pipeline.sAdd('revalidated-tags', tag)
-      localTagTimestamps.set(tag, now)
-    }
-    await pipeline.exec()
-  },
-}
-```
-
-For a full explanation of the tag architecture (including soft tags and multi-instance considerations), see [How Revalidation Works](/docs/app/guides/how-revalidation-works).
-
-## Soft Tags
-
-Soft tags are implicit tags that Next.js automatically generates based on the route path. Every segment in the path gets a layout tag, plus the leaf route itself. For example, the route `/blog/hello` generates soft tags for `/layout`, `/blog/layout`, `/blog/hello/layout`, and `/blog/hello`. These tags are prefixed internally with `_N_T_`.
-
-Soft tags enable [`revalidatePath()`](/docs/app/api-reference/functions/revalidatePath) to work through the same tag-based cache system. When `revalidatePath('/blog/hello')` is called, it invalidates all cache entries associated with that path's soft tags.
-
-In the cache handler API, soft tags are passed to the [`get()`](#get) method as the `softTags` parameter. Your handler should check whether any soft tag has been invalidated (via `getExpiration()` or direct timestamp comparison) after the cache entry's `timestamp`. If a soft tag was invalidated more recently than the entry was created, the entry should be treated as stale.
-
-## Handling Streams
-
-The `CacheEntry.value` is a [`ReadableStream<Uint8Array>`](https://developer.mozilla.org/docs/Web/API/ReadableStream). When implementing a cache handler that stores entries externally, keep in mind:
-
-- **Use `.tee()`** if you need to both store and return the stream. One branch goes to storage, the other is returned to the caller.
-- **Memory implications**: large pages produce large cache entries. For S3-like storage backends, consider streaming directly to storage without buffering the entire entry in memory.
-- **Partial writes**: the stream may error partway through rendering. Your handler should decide whether to keep partial entries or discard them. Discarding is safer, as partial entries can produce incomplete pages.
-
-## Error Handling
-
-Cache operations should be implemented defensively:
-
-- **`set()` failure**: the response is still served to the user because `set()` is called asynchronously after the response stream is already flowing. The cache entry is lost, and the next request triggers a fresh render.
-- **`get()` failure**: your handler should catch internal errors and return `undefined` (the "cache miss" signal). The framework does not wrap `get()` in a try/catch, so an unhandled exception from `get()` will propagate as a render error.
-- **Partial writes**: if a cache entry is partially written and then read, the behavior is undefined. Use atomic writes or a write-then-rename pattern to avoid serving partial entries.
-
 ## Platform Support
 
 | Deployment Option                                                   | Supported         |
diff --git a/packages/next/src/server/image-optimizer.ts b/packages/next/src/server/image-optimizer.ts
index 1e6f4daf1f3d..581e082f13b4 100644
--- a/packages/next/src/server/image-optimizer.ts
+++ b/packages/next/src/server/image-optimizer.ts
@@ -47,10 +47,6 @@ const CACHE_VERSION = 4
 const BLUR_IMG_SIZE = 8 // should match `next-image-loader`
 const BLUR_QUALITY = 70 // should match `next-image-loader`
 
-function isValidMime(contentType: string) {
-  return Boolean(getExtension(contentType))
-}
-
 async function initCacheEntries(
   cacheDir: string
 ): Promise<Array<{ key: string; size: number; expireAt: number }>> {
@@ -769,7 +765,6 @@ export async function imageOptimizer(
   )
 
   return imageOptimizerTransform(imageUpstream, paramsResult, nextConfig, {
-    isValidMime,
     previousOutput: previouslyCachedImage
       ? {
           buffer: previouslyCachedImage.buffer,
diff --git a/packages/next/src/server/image-optimizer/transform.ts b/packages/next/src/server/image-optimizer/transform.ts
index c89ec5d7ed79..548e605d2846 100644
--- a/packages/next/src/server/image-optimizer/transform.ts
+++ b/packages/next/src/server/image-optimizer/transform.ts
@@ -62,7 +62,6 @@ export interface ImageOptimizerTransformLogger {
 }
 
 export interface ImageOptimizerTransformOptions {
-  isValidMime: (contentType: string) => boolean
   previousOutput?: {
     buffer: Buffer
     maxAge?: number
@@ -195,7 +194,7 @@ export async function imageOptimizerTransform(
   imageUpstream: ImageUpstream,
   paramsResult: ImageOptimizerTransformParams,
   nextConfig: ImageOptimizerTransformConfig,
-  opts: ImageOptimizerTransformOptions
+  opts: ImageOptimizerTransformOptions = {}
 ): Promise<ImageOptimizerResult> {
   const { href, quality, width, mimeType } = paramsResult
   const { buffer: upstreamBuffer, etag: upstreamEtag } = imageUpstream
@@ -256,14 +255,11 @@ export async function imageOptimizerTransform(
 
   if (mimeType) {
     contentType = mimeType
-  } else if (
-    opts.isValidMime(upstreamType) &&
-    upstreamType !== WEBP &&
-    upstreamType !== AVIF
-  ) {
-    contentType = upstreamType
-  } else {
+  } else if (upstreamType === WEBP || upstreamType === AVIF) {
+    // Downlevel WebP and AVIF when the client does not advertise support.
     contentType = JPEG
+  } else {
+    contentType = upstreamType
   }
 
   if (opts.previousOutput) {
@@ -301,21 +297,14 @@ export async function imageOptimizerTransform(
       upstreamEtag,
     }
   } catch (error) {
-    if (upstreamType) {
-      // If we fail to optimize, fallback to the original image
-      return {
-        buffer: upstreamBuffer,
-        contentType: upstreamType,
-        maxAge: nextConfig.images.minimumCacheTTL,
-        etag: upstreamEtag,
-        upstreamEtag,
-        error,
-      }
-    } else {
-      throw new ImageError(
-        400,
-        'Unable to optimize image and unable to fallback to upstream image'
-      )
+    // If we fail to optimize, fallback to the original image
+    return {
+      buffer: upstreamBuffer,
+      contentType: upstreamType,
+      maxAge: nextConfig.images.minimumCacheTTL,
+      etag: upstreamEtag,
+      upstreamEtag,
+      error,
     }
   }
 }
diff --git a/packages/next/src/server/lib/cache-handlers/default.test.ts b/packages/next/src/server/lib/cache-handlers/default.test.ts
index 01ead53e8458..34139f6a2138 100644
--- a/packages/next/src/server/lib/cache-handlers/default.test.ts
+++ b/packages/next/src/server/lib/cache-handlers/default.test.ts
@@ -12,6 +12,20 @@ setFlagsFromString('--expose-gc')
 const forceGarbageCollection = runInNewContext('gc') as () => void
 
 describe('default use cache handler', () => {
+  /**
+   * These tests guard the handler against retaining the request that filled or
+   * read an entry. Whether a regression here fails depends on the
+   * `AsyncLocalStorage` implementation of the environment:
+   *
+   * - Node 20 and 22 attach the active store to every promise, so a retained
+   *   stream keeps the store reachable, and these tests fail on a regression.
+   * - Node 24 and later use `AsyncContextFrame`, and these tests pass with or
+   *   without the retention.
+   *
+   * CI runs Node 20.9, so the guard holds there. A regression is invisible to a
+   * developer who runs the suite on Node 24 or later.
+   */
+
   it('does not retain the async context that populated an entry', async () => {
     const handler = createDefaultCacheHandler(1024 * 1024)
     const requestStoreRef = await runInRequestContext(() =>
diff --git a/packages/next/src/server/lib/cache-handlers/types.ts b/packages/next/src/server/lib/cache-handlers/types.ts
index eee58946be7c..8a9a99bb5b0a 100644
--- a/packages/next/src/server/lib/cache-handlers/types.ts
+++ b/packages/next/src/server/lib/cache-handlers/types.ts
@@ -5,9 +5,24 @@ export type Timestamp = number
 
 export interface CacheEntry {
   /**
-   * The ReadableStream can error and only have partial data so any cache
-   * handlers need to handle this case and decide to keep the partial cache
-   * around or not.
+   * The serialized value of the entry. A cache handler consumes this stream in
+   * `set` and persists what it delivers. A handler can buffer the stream, or it
+   * can pipe it to its storage as chunks arrive. Two rules apply either way:
+   *
+   * - A handler must return a new stream from every `get`.
+   * - A handler must not retain the stream after `set` resolves.
+   *
+   * A stream can be read one time only. A second reader of the same stream gets
+   * no data, or an error while the first reader holds the lock. A retained
+   * stream also keeps a reference to the async context of the request that
+   * created it, which keeps the state of that request reachable for as long as
+   * the entry lives.
+   *
+   * The same applies to the `pendingEntry` promise that `set` receives. A
+   * handler must not put that promise in a map that outlives the request.
+   *
+   * The stream can error and deliver partial data. Each handler decides whether
+   * it keeps the partial entry or discards it.
    */
   value: ReadableStream<Uint8Array>
 
@@ -30,11 +45,22 @@ export interface CacheEntry {
   /**
    * How long the entry is allowed to be used (should be longer than revalidate)
    * [duration in seconds]
+   *
+   * This is the hard limit. Next.js compares it against `timestamp` on every
+   * read and treats a too-old entry as a miss, so a handler does not need to
+   * check the age of an entry before it returns one. The dev server raises the
+   * limit to five minutes when `expire` is shorter, to keep reloads fast.
    */
   expire: number
 
   /**
    * How long until the entry should be revalidated [duration in seconds]
+   *
+   * An entry that is past `revalidate` but within `expire` is still served, and
+   * Next.js generates a fresh one in the background. A negative value always
+   * lies in the past, so it forces that background refresh on the next read.
+   * The built-in handler returns `-1` for an entry whose tag is stale, which
+   * serves the entry one more time and replaces it.
    */
   revalidate: number
 }
@@ -42,7 +68,10 @@ export interface CacheEntry {
 export interface CacheHandler {
   /**
    * Retrieve a cache entry for the given cache key, if available. Will return
-   * undefined if there's no valid entry, or if the given soft tags are stale.
+   * undefined if there's nothing stored, or if the given soft tags are stale.
+   *
+   * Each call returns a new `value` stream over the stored bytes. See
+   * `CacheEntry.value`.
    */
   get(cacheKey: string, softTags: string[]): Promise<undefined | CacheEntry>
 
@@ -53,12 +82,20 @@ export interface CacheHandler {
    * before the pending entry is complete, the cache handler must wait for the
    * `set` operation to finish, before returning the entry, instead of returning
    * undefined.
+   *
+   * The handler takes ownership of the entry's `value` stream, and consumes it
+   * exactly once. See `CacheEntry.value`.
+   *
+   * The handler also owns eviction. Next.js never removes an entry from the
+   * store, so the store needs a mechanism of its own, such as a time to live
+   * from `expire`, or a size-bounded LRU.
    */
   set(cacheKey: string, pendingEntry: Promise<CacheEntry>): Promise<void>
 
   /**
-   * This function may be called periodically, but always before starting a new
-   * request. If applicable, it should communicate with the tags service to
+   * This function is called once per request, before the first cache read for
+   * this handler's kind. A request that reads nothing from this handler does
+   * not call it. If applicable, it should communicate with the tags service to
    * refresh the local tags manifest accordingly.
    */
   refreshTags(): Promise<void>
diff --git a/packages/next/src/server/stream-utils/node-web-streams-helper.ts b/packages/next/src/server/stream-utils/node-web-streams-helper.ts
index 0d7e5e66d00f..9258748757af 100644
--- a/packages/next/src/server/stream-utils/node-web-streams-helper.ts
+++ b/packages/next/src/server/stream-utils/node-web-streams-helper.ts
@@ -87,6 +87,17 @@ export function streamFromString(str: string): ReadableStream<Uint8Array> {
   })
 }
 
+/**
+ * Creates a stream that delivers `chunk` and then closes.
+ *
+ * The stream is a default stream, and it has to stay one. A byte stream (`type:
+ * 'bytes'`) transfers the buffer of each chunk that it receives, which detaches
+ * `chunk`. A caller that keeps `chunk` to serve more than one read, such as an
+ * in-memory cache handler, loses the data on the first read.
+ *
+ * Every reader receives the same `chunk` instance. A reader that modifies it
+ * changes what later readers see.
+ */
 export function streamFromBuffer(chunk: Buffer): ReadableStream<Uint8Array> {
   return new ReadableStream({
     start(controller) {
diff --git a/packages/next/src/server/use-cache/tiered-cache-handler.ts b/packages/next/src/server/use-cache/tiered-cache-handler.ts
index a5e8b3eeacab..80997f93a3a2 100644
--- a/packages/next/src/server/use-cache/tiered-cache-handler.ts
+++ b/packages/next/src/server/use-cache/tiered-cache-handler.ts
@@ -158,10 +158,12 @@ async function reconcileFrontFromBacking(
     if (backingEntry.timestamp > frontEntry.timestamp) {
       await front.set(cacheKey, Promise.resolve(backingEntry))
     } else {
-      // The front is already up to date, so the backing entry goes unused.
-      // Release its stream without awaiting: a teed stream's `cancel()` only
-      // settles once the sibling branch (retained by the backing handler) is
-      // also cancelled, so awaiting it here would hang the reconcile.
+      // The front is already up to date, so the backing entry goes unused. This
+      // code releases its stream and does not await the result. The backing
+      // handler is user-configured, and it can return one branch of a teed
+      // stream. `cancel()` on such a branch settles only after the sibling
+      // branch is cancelled too, and the handler retains that sibling, so an
+      // await here would hang the reconcile.
       void backingEntry.value.cancel()
     }
   } catch {
diff --git a/test/development/app-dir/cache-components-spurious-cache-invalidation/fixtures/persistent-handler/handler.js b/test/development/app-dir/cache-components-spurious-cache-invalidation/fixtures/persistent-handler/handler.js
index 59319593caac..696ba1e83b37 100644
--- a/test/development/app-dir/cache-components-spurious-cache-invalidation/fixtures/persistent-handler/handler.js
+++ b/test/development/app-dir/cache-components-spurious-cache-invalidation/fixtures/persistent-handler/handler.js
@@ -8,6 +8,7 @@ const crypto = require('node:crypto')
 
 const cacheDir = path.join(__dirname, '.file-system-cache')
 
+/** @param {string} cacheKey */
 function filePathForKey(cacheKey) {
   const hash = crypto.createHash('sha256').update(cacheKey).digest('hex')
   return path.join(cacheDir, `${hash}.json`)
diff --git a/test/e2e/app-dir/use-cache-custom-handler/handler.js b/test/e2e/app-dir/use-cache-custom-handler/handler.js
index 2d2c2a1ad3a6..35053425e737 100644
--- a/test/e2e/app-dir/use-cache-custom-handler/handler.js
+++ b/test/e2e/app-dir/use-cache-custom-handler/handler.js
@@ -35,9 +35,7 @@ const cacheHandler = {
 
   async getExpiration(tags) {
     console.log('ModernCustomCacheHandler::getExpiration', JSON.stringify(tags))
-    // Expecting soft tags in `get` to be used by the cache handler for checking
-    // the expiration of a cache entry, instead of letting Next.js handle it.
-    return Infinity
+    return defaultCacheHandler.getExpiration(tags)
   },
 
   async updateTags(tags) {
diff --git a/test/e2e/cache-handlers-upstream-wiring/fixtures/non-edge-cache-components/modern-cache-handler.js b/test/e2e/cache-handlers-upstream-wiring/fixtures/non-edge-cache-components/modern-cache-handler.js
index 30e4cf3b8ecf..0e58134f91a7 100644
--- a/test/e2e/cache-handlers-upstream-wiring/fixtures/non-edge-cache-components/modern-cache-handler.js
+++ b/test/e2e/cache-handlers-upstream-wiring/fixtures/non-edge-cache-components/modern-cache-handler.js
@@ -24,7 +24,7 @@ const cacheHandler = {
 
   async getExpiration(tags) {
     console.log('WiringModernCacheHandler::getExpiration', JSON.stringify(tags))
-    return Infinity
+    return defaultCacheHandler.getExpiration(tags)
   },
 
   async updateTags(tags) {
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/get-data.ts b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/get-data.ts
index 4b62504ea037..cfd357242600 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/get-data.ts
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/get-data.ts
@@ -1,7 +1,10 @@
+globalThis.noop = () => {}
+
 export async function getData(action) {
   'use cache: remote'
 
-  console.log(action)
+  // Pretend to use it
+  globalThis.noop(action)
 
   return Math.random()
 }
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/page.tsx
index 37edb04ff7f3..34968b78596d 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-cache/page.tsx
@@ -2,6 +2,8 @@ import { connection } from 'next/server'
 import { action } from './action'
 import { getData } from './get-data'
 
+export const instant = false
+
 export default async function Page() {
   await connection()
 
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/client.tsx b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/client.tsx
index fc07343ca9c0..499545d44878 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/client.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/client.tsx
@@ -1,5 +1,21 @@
 'use client'
 
-export function client() {
-  return 'first'
+import { useState } from 'react'
+
+export function Client() {
+  const [text, setText] = useState('')
+
+  return (
+    <div>
+      <div id="title">Client Component A</div>
+      <button
+        onClick={() => {
+          setText('Button clicked')
+        }}
+      >
+        Click me
+      </button>
+      <span id="state">{text}</span>
+    </div>
+  )
 }
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.ts b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.ts
deleted file mode 100644
index 0dcfdc19520c..000000000000
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export async function getData(client) {
-  'use cache: remote'
-
-  console.log(client)
-
-  return Math.random()
-}
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.tsx b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.tsx
new file mode 100644
index 000000000000..2e20c356d2d7
--- /dev/null
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/get-data.tsx
@@ -0,0 +1,10 @@
+export async function getData(Client) {
+  'use cache: remote'
+
+  return (
+    <div>
+      <span id="data">{Math.random()}</span>
+      <Client />
+    </div>
+  )
+}
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/page.tsx
index 02fa0fd11a36..604275d6b061 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-client/page.tsx
@@ -1,9 +1,11 @@
 import { connection } from 'next/server'
-import { client } from './client'
+import { Client } from './client'
 import { getData } from './get-data'
 
+export const instant = false
+
 export default async function Page() {
   await connection()
 
-  return <span id="data">{await getData(client)}</span>
+  return <div>{await getData(Client)}</div>
 }
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/get-data.ts b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/get-data.ts
index 4b62504ea037..cfd357242600 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/get-data.ts
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/get-data.ts
@@ -1,7 +1,10 @@
+globalThis.noop = () => {}
+
 export async function getData(action) {
   'use cache: remote'
 
-  console.log(action)
+  // Pretend to use it
+  globalThis.noop(action)
 
   return Math.random()
 }
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/page.tsx
index 37edb04ff7f3..34968b78596d 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/argument-use-server/page.tsx
@@ -2,6 +2,8 @@ import { connection } from 'next/server'
 import { action } from './action'
 import { getData } from './get-data'
 
+export const instant = false
+
 export default async function Page() {
   await connection()
 
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/client/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/client/page.tsx
index 39b38020aaba..5ed468ec6dc0 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/client/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/client/page.tsx
@@ -10,6 +10,8 @@ async function DynamicCache({ id }: { id: string }) {
   return <Client>{getDate()}</Client>
 }
 
+export const instant = false
+
 export default async function Page() {
   await connection()
 
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/nested/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/nested/page.tsx
index 17b39bc213b2..72fc1ea2b897 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/nested/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/nested/page.tsx
@@ -13,6 +13,8 @@ async function getOuterData() {
   return getInnerData()
 }
 
+export const instant = false
+
 export default async function Page() {
   await connection()
 
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/page.tsx
index 9bb9b6d57b5d..ac200a6924ba 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/page.tsx
@@ -14,6 +14,8 @@ async function AsyncComp() {
   return <span id="data">{data}</span>
 }
 
+export const instant = false
+
 export default async function Home() {
   await connection()
 
diff --git a/test/production/app-dir/use-cache-cross-deployment/app/prerender/page.tsx b/test/production/app-dir/use-cache-cross-deployment/app/prerender/page.tsx
index aad28420e07c..d747d7c0117c 100644
--- a/test/production/app-dir/use-cache-cross-deployment/app/prerender/page.tsx
+++ b/test/production/app-dir/use-cache-cross-deployment/app/prerender/page.tsx
@@ -8,6 +8,8 @@ async function DynamicCache({ id }: { id: string }) {
   return <span id="data">{getDate()}</span>
 }
 
+export const instant = false
+
 export default function Page() {
   return (
     <main>
diff --git a/test/production/app-dir/use-cache-cross-deployment/handler-remote.js b/test/production/app-dir/use-cache-cross-deployment/handler-remote.js
index 93078381c104..7265feb7daa2 100644
--- a/test/production/app-dir/use-cache-cross-deployment/handler-remote.js
+++ b/test/production/app-dir/use-cache-cross-deployment/handler-remote.js
@@ -3,117 +3,209 @@
 const fs = require('fs')
 const path = require('path')
 
+const dataFilePath = path.join(__dirname, 'handler-remote-data.json')
+
 /**
- * @type {Record<string, string>}
+ * @type {Record<string, { value: string, expiresAt?: number }>}
  */
 let data = {}
 try {
-  data = JSON.parse(
-    fs.readFileSync(path.join(__dirname, 'handler-remote-data.json'), 'utf8')
-  )
+  data = JSON.parse(fs.readFileSync(dataFilePath, 'utf8'))
 } catch (_e) {}
 
+function persistData() {
+  fs.writeFileSync(dataFilePath, JSON.stringify(data, null, 2))
+}
+
+// Date.now is considered sync IO by cache components
+const now = () => performance.timeOrigin + performance.now()
+
+// This is a Redis-like interface.
 const client = {
   /**
    * @param {string} key
-   * @returns unknown
+   * @returns {Promise<string | undefined>}
    */
   async get(key) {
-    return data[key]
+    const stored = data[key]
+    if (!stored) return undefined
+
+    if (stored.expiresAt !== undefined && stored.expiresAt <= now()) {
+      delete data[key]
+      persistData()
+      return undefined
+    }
+
+    return stored.value
   },
   /**
-   *
    * @param {string} key
    * @param {string} value
    * @param {{expire?: number} | undefined} options
    */
   async set(key, value, options) {
-    // options.expire is ignored in this impl
-    data[key] = value
-    fs.writeFileSync(
-      path.join(__dirname, 'handler-remote-data.json'),
-      JSON.stringify(data, null, 2)
-    )
+    if (options?.expire !== undefined && options.expire <= 0) {
+      delete data[key]
+    } else {
+      data[key] = {
+        value,
+        expiresAt:
+          options?.expire === undefined
+            ? undefined
+            : now() + options.expire * 1000,
+      }
+    }
+    persistData()
   },
 }
 
+/** @type {Map<string, Promise<void>>} */
+const pendingSets = new Map()
+
+/** @param {string} cacheKey */
+const entryKey = (cacheKey) => `entry:${cacheKey}`
+/** @param {string} tag */
+const tagKey = (tag) => `tag:${tag}`
+
+/**
+ * @typedef {{ stale?: number, expired?: number }} TagManifestEntry
+ */
+
+/**
+ * @param {string} tag
+ * @returns {Promise<TagManifestEntry>}
+ */
+async function getTagManifestEntry(tag) {
+  const stored = await client.get(tagKey(tag))
+  return stored ? JSON.parse(stored) : {}
+}
+
 /**
  * @type {import('next/dist/server/lib/cache-handlers/types').CacheHandler}
  */
 module.exports = {
   async get(cacheKey, softTags) {
     console.log('CustomCacheHandler::get', cacheKey, JSON.stringify([softTags]))
-    // Retrieve from Redis
-    const stored = await client.get(cacheKey)
+
+    const pendingSet = pendingSets.get(cacheKey)
+    if (pendingSet) {
+      await pendingSet
+    }
+
+    const stored = await client.get(entryKey(cacheKey))
     if (!stored) return undefined
 
     // Deserialize the entry
-    const data = JSON.parse(stored)
+    const entry = JSON.parse(stored)
+
+    let revalidate = entry.revalidate
+    for (const tag of entry.tags) {
+      const tagManifestEntry = await getTagManifestEntry(tag)
+      if (
+        tagManifestEntry.expired !== undefined &&
+        tagManifestEntry.expired <= now() &&
+        tagManifestEntry.expired > entry.timestamp
+      ) {
+        return undefined
+      }
+      if (
+        tagManifestEntry.stale !== undefined &&
+        tagManifestEntry.stale > entry.timestamp
+      ) {
+        revalidate = -1
+      }
+    }
 
     // Reconstruct the ReadableStream from stored data
     return {
       value: new ReadableStream({
         start(controller) {
-          controller.enqueue(Buffer.from(data.value, 'base64'))
+          controller.enqueue(Buffer.from(entry.value, 'base64'))
           controller.close()
         },
       }),
-      tags: data.tags,
-      stale: data.stale,
-      timestamp: data.timestamp,
-      expire: data.expire,
-      revalidate: data.revalidate,
+      tags: entry.tags,
+      stale: entry.stale,
+      timestamp: entry.timestamp,
+      expire: entry.expire,
+      revalidate,
     }
   },
 
   async set(cacheKey, pendingEntry) {
     console.log('CustomCacheHandler::set', cacheKey)
-    const entry = await pendingEntry
-
-    // Read the stream to get the data
-    const reader = entry.value.getReader()
-    const chunks = []
+    /** @type {() => void} */
+    let resolvePending = () => {}
+    /** @type {Promise<void>} */
+    const pendingSet = new Promise((resolve) => {
+      resolvePending = /** @type {() => void} */ (resolve)
+    })
+    pendingSets.set(cacheKey, pendingSet)
 
     try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        chunks.push(value)
+      const entry = await pendingEntry
+
+      // Read the stream to get the data
+      const reader = entry.value.getReader()
+      /** @type {Uint8Array[]} */
+      const chunks = []
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          chunks.push(value)
+        }
+      } finally {
+        reader.releaseLock()
       }
+
+      // Combine chunks and serialize
+      const value = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)))
+
+      await client.set(
+        entryKey(cacheKey),
+        JSON.stringify({
+          value: value.toString('base64'),
+          tags: entry.tags,
+          stale: entry.stale,
+          timestamp: entry.timestamp,
+          expire: entry.expire,
+          revalidate: entry.revalidate,
+        }),
+        { expire: entry.expire }
+      )
     } finally {
-      reader.releaseLock()
+      resolvePending()
+      pendingSets.delete(cacheKey)
     }
-
-    // Combine chunks and serialize for Redis storage
-    const data = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)))
-
-    await client.set(
-      cacheKey,
-      JSON.stringify({
-        value: data.toString('base64'),
-        tags: entry.tags,
-        stale: entry.stale,
-        timestamp: entry.timestamp,
-        expire: entry.expire,
-        revalidate: entry.revalidate,
-      }),
-      { expire: entry.expire }
-    )
   },
 
   async refreshTags() {
-    // No-op for basic Redis implementation
-    // Could sync with external tag service if needed
+    // Tags are read directly from the remote store, so there is nothing to sync.
   },
 
   async getExpiration(tags) {
-    // Return 0 to indicate no tags have been revalidated
-    // Could query Redis for tag expiration timestamps if tracking them
-    return 0
+    const entries = await Promise.all(tags.map(getTagManifestEntry))
+    return Math.max(...entries.map((entry) => entry.expired || 0), 0)
   },
 
   async updateTags(tags, durations) {
-    // Implement tag-based invalidation if needed
-    // Could iterate over keys with matching tags and delete them
+    const currentTime = now()
+
+    await Promise.all(
+      tags.map(async (tag) => {
+        const entry = await getTagManifestEntry(tag)
+        if (durations) {
+          entry.stale = currentTime
+          if (durations.expire !== undefined) {
+            entry.expired = currentTime + durations.expire * 1000
+          }
+        } else {
+          entry.expired = currentTime
+        }
+        await client.set(tagKey(tag), JSON.stringify(entry), undefined)
+      })
+    )
   },
 }
diff --git a/test/production/app-dir/use-cache-cross-deployment/handler.js b/test/production/app-dir/use-cache-cross-deployment/handler.js
index 9cb7a84162bc..a3129b4e9427 100644
--- a/test/production/app-dir/use-cache-cross-deployment/handler.js
+++ b/test/production/app-dir/use-cache-cross-deployment/handler.js
@@ -22,9 +22,7 @@ const cacheHandler = {
   },
 
   async getExpiration(tags) {
-    // Expecting soft tags in `get` to be used by the cache handler for checking
-    // the expiration of a cache entry, instead of letting Next.js handle it.
-    return Infinity
+    return defaultCacheHandler.getExpiration(tags)
   },
 
   async updateTags(tags) {
diff --git a/test/production/app-dir/use-cache-cross-deployment/public/favicon.ico b/test/production/app-dir/use-cache-cross-deployment/public/favicon.ico
deleted file mode 100644
index 4965832f2c9b..000000000000
Binary files a/test/production/app-dir/use-cache-cross-deployment/public/favicon.ico and /dev/null differ
diff --git a/test/production/app-dir/use-cache-cross-deployment/use-cache-cross-deployment.test.ts b/test/production/app-dir/use-cache-cross-deployment/use-cache-cross-deployment.test.ts
index 2e3d5a8e10a3..de29014a2ec0 100644
--- a/test/production/app-dir/use-cache-cross-deployment/use-cache-cross-deployment.test.ts
+++ b/test/production/app-dir/use-cache-cross-deployment/use-cache-cross-deployment.test.ts
@@ -241,6 +241,7 @@ describe.each(['NEXT_DEPLOYMENT_ID', 'BUILD_ID', 'default'])(
 
     // TODO when serializing server reference arguments, we need to include the server reference's
     // entropy in the argument-part of the cache key.
+    // But currently, you cannot do anything with the passed server reference anyway.
     it.skip('should recompute when a use cache reference argument changes', async () => {
       const key1 = await execute(next, 'NEXT_DEPLOYMENT_ID', 'dpl-id-1')
 
@@ -258,7 +259,8 @@ describe.each(['NEXT_DEPLOYMENT_ID', 'BUILD_ID', 'default'])(
 
     // TODO when serializing server reference arguments, we need to include the server reference's
     // entropy in the argument-part of the cache key.
-    // Furthermore, we need to compute the metadata information for use-server functions.
+    // But currently, you cannot do anything with the passed server reference anyway.
+    // Furthermore, we need to compute the metadata information for `use cache` functions as well.
     it.skip('should recompute when a use server reference argument changes', async () => {
       const key1 = await execute(next, 'NEXT_DEPLOYMENT_ID', 'dpl-id-1')
 
@@ -349,22 +351,29 @@ describe.each(['NEXT_DEPLOYMENT_ID', 'BUILD_ID', 'default'])(
       )
     })
 
-    // TODO this seems like a preexisting bug? The reference gets serialized into the cache key as just "$T"
-    it.skip('should recompute when a client reference argument changes', async () => {
+    it('should work still when a client reference argument changes', async () => {
+      // The client reference is passed as an opaque argument. Instead, we need to make sure that
+      // the client reference still uses the up-to-date chunks.
       const key1 = await execute(next, 'NEXT_DEPLOYMENT_ID', 'dpl-id-1')
       await next.patchFile(
         'app/argument-use-client/client.tsx',
         (oldContent) =>
-          oldContent.replace(
-            "'use client'",
-            "'use client'\n\nawait Promise.resolve()"
-          ),
+          oldContent
+            .replace('Client Component A', 'Client Component B')
+            .replace('Button clicked', 'Handle clicked'),
         async () => {
           const key2 = await execute(next, 'NEXT_DEPLOYMENT_ID', 'dpl-id-2')
 
-          expect(key1.keyArgumentUseClient).not.toBe(key2.keyArgumentUseClient)
-          expect(key1.dataArgumentUseClient).not.toBe(
-            key2.dataArgumentUseClient
+          expect(key1.keyArgumentUseClient).toBe(key2.keyArgumentUseClient)
+          expect(key1.dataArgumentUseClient).toBe(key2.dataArgumentUseClient)
+
+          const browser = await next.browser('/argument-use-client')
+          expect(await browser.elementById('title').text()).toBe(
+            'Client Component B'
+          )
+          await browser.elementByCss('button').click()
+          expect(await browser.elementById('state').text()).toBe(
+            'Handle clicked'
           )
         }
       )
diff --git a/test/production/custom-server/cache-handler.js b/test/production/custom-server/cache-handler.js
index 6ee7e200fccf..2ef218d801c0 100644
--- a/test/production/custom-server/cache-handler.js
+++ b/test/production/custom-server/cache-handler.js
@@ -9,8 +9,8 @@ const defaultCacheHandler =
  * @type {import('next/dist/server/lib/cache-handlers/types').CacheHandler}
  */
 const cacheHandler = {
-  async get(cacheKey) {
-    return defaultCacheHandler.get(cacheKey)
+  async get(cacheKey, softTags) {
+    return defaultCacheHandler.get(cacheKey, softTags)
   },
 
   async set(cacheKey, pendingEntry) {
diff --git a/test/unit/image-optimizer/transform.test.ts b/test/unit/image-optimizer/transform.test.ts
index 2c7d79b44ed4..f251eb8ebab1 100644
--- a/test/unit/image-optimizer/transform.test.ts
+++ b/test/unit/image-optimizer/transform.test.ts
@@ -1,10 +1,7 @@
 /* eslint-env jest */
 import { readFile } from 'fs-extra'
 import { join } from 'path'
-import {
-  imageOptimizerTransform,
-  type ImageOptimizerTransformOptions,
-} from 'next/dist/server/image-optimizer/transform'
+import { imageOptimizerTransform } from 'next/dist/server/image-optimizer/transform'
 import type {
   CachedRouteKind,
   IncrementalResponseCacheEntry,
@@ -13,8 +10,6 @@ import type {
 const getImage = (filename: string) =>
   readFile(join(__dirname, 'images', filename))
 
-const isValidMime = (contentType: string) => contentType === 'image/png'
-
 const config = {
   images: {
     dangerouslyAllowSVG: true,
@@ -29,11 +24,7 @@ const config = {
   },
 }
 
-async function transform(
-  filename: string,
-  mimeType = 'image/webp',
-  options?: ImageOptimizerTransformOptions
-) {
+async function transform(filename: string, mimeType = 'image/webp') {
   const buffer = await getImage(filename)
   return imageOptimizerTransform(
     {
@@ -43,8 +34,7 @@ async function transform(
       etag: 'source-etag',
     },
     { href: `/${filename}`, width: 64, quality: 75, mimeType },
-    config,
-    { isValidMime, ...options }
+    config
   )
 }
 
@@ -110,6 +100,11 @@ describe('imageOptimizerTransform', () => {
     expect(result.contentType).toBe('image/webp')
   })
 
+  it('downlevels an avif source when no output format is requested', async () => {
+    const result = await transform('test.avif', '')
+    expect(result.contentType).toBe('image/jpeg')
+  })
+
   it('generates blur placeholders in development', async () => {
     const result = await transformInDevelopment('test.png')
     expect(result.contentType).toBe('image/svg+xml')
@@ -167,8 +162,7 @@ describe('imageOptimizerTransform', () => {
         {
           ...config,
           images: { ...config.images, dangerouslyAllowSVG: false },
-        },
-        { isValidMime }
+        }
       )
     ).rejects.toMatchObject({ statusCode: 400 })
   })
@@ -183,8 +177,7 @@ describe('imageOptimizerTransform', () => {
           etag: 'source-etag',
         },
         { href: '/bad', width: 64, quality: 75, mimeType: 'image/webp' },
-        config,
-        { isValidMime }
+        config
       )
     ).rejects.toMatchObject({ statusCode: 400 })
   })