@rangojs/router 0.33.1 → 0.34.0

package/dist/types/testing/serve-shell-request.d.ts

@@ -66,13 +66,13 @@ export interface ServeShellRequestOptions<TEnv = any> {
      * `result.replayStatus`.
      *
      * `prefetch: true` sends the speculative kind a viewport or render
-     * `<Link>` prefetch sends (`X-Rango-Prefetch: 1`), so `prefetch: false`
-     * loaders and `loading()` entries are deferred: `result.readDeferred()`
-     * lists them. A hover's or `prefetch()`'s intent prefetch defers nothing;
-     * serve it with `prefetch: true` and `headers: { "X-Rango-Prefetch":
-     * "intent" }`, which `prefetch: true` leaves as given. `fill: true`
-     * sends the request the browser follows an adopted prefetch with
-     * (`_rsc_fill`): pass the ids the prefetch delivered, without the deferred
+     * `<Link>` prefetch sends (`X-Rango-Prefetch: 1`), so loaders and
+     * `loading()` entries flagged `prefetch: false` or `"intent"` are deferred:
+     * `result.readDeferred()` lists them. A hover's intent prefetch defers
+     * `false` only; serve it with `prefetch: true` and `headers: {
+     * "X-Rango-Prefetch": "intent" }`, which `prefetch: true` leaves as given.
+     * `fill: true` sends the request the browser follows an adopted prefetch
+     * with (`_rsc_fill`): pass the ids the prefetch delivered, without the deferred
      * ones, as `segments`, and the same URL as `from`. `interceptSource` sends
      * the intercept source (`X-RSC-Router-Intercept-Source`) the browser sends
      * from an open modal and with the fill of an intercept, whose `from` is

package/dist/types/testing/vitest-stubs/plugin-rsc-browser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Stub for `@vitejs/plugin-rsc/browser`, shipped so consumers do not have to
+ * write a per-file `vi.mock(...)`. The real entry imports the
+ * `virtual:vite-rsc/client-references` Vite virtual at the top level, which a
+ * bare Vitest process cannot resolve.
+ *
+ * The router reaches this module from `useLoader().load()` and a
+ * `refreshGroup` refresh (use-loader.tsx imports deps/browser.ts lazily).
+ * renderRoute answers those requests (render-route.tsx), and a DOM test has
+ * no Flight server to encode an answer: renderRoute's seeds are client values
+ * already. So the answer travels with its Response object, and
+ * `createFromFetch` hands it back unchanged, as a decoded payload. Any other
+ * response is rejected. The remaining exports exist for the re-export in
+ * deps/browser.ts; navigations, actions and the document are not decoded
+ * here.
+ */
+/**
+ * A loader endpoint Response whose decoded payload is `payload`
+ * (`{ loaderResult }` or `{ loaderResult: null, loaderError }`, as
+ * rsc/loader-fetch.ts answers).
+ */
+export declare function loaderAnswerResponse(payload: {
+    loaderResult: unknown;
+    loaderError?: {
+        message: string;
+        name: string;
+    };
+}): Response;
+export declare function createFromFetch<T>(response: Promise<Response> | Response): Promise<T>;
+export declare const createFromReadableStream: () => Promise<never>;
+export declare const encodeReply: () => Promise<never>;
+export declare const setServerCallback: () => void;
+export declare const createTemporaryReferenceSet: () => unknown;

package/dist/types/types/loader-types.d.ts

@@ -7,6 +7,7 @@ import type { SearchSchema, ResolveSearchSchema } from "../search-params.js";
 import type { UseItems, LoaderUseItem } from "../route-types.js";
 import type { DefaultEnv, DefaultReverseRouteMap, DefaultVars } from "./global-namespace.js";
 import type { RequestScope } from "./request-scope.js";
+import type { PrefetchOption } from "../prefetch-markers.js";
 /**
  * Context passed to loader functions during execution
  *
@@ -182,13 +183,14 @@ export type LoaderFn<T, TParams = Record<string, string | undefined>, TEnv = Def
 export type LoaderOptions = {
     ssr?: boolean;
     /**
-     * `prefetch: false` keeps this loader out of speculative prefetches. A
-     * viewport or render `<Link>` prefetch (a partial request with
-     * `X-Rango-Prefetch: 1`) does not execute it; the payload marks it
-     * deferred. A hover prefetch and `useRouter().prefetch()`
-     * (`X-Rango-Prefetch: intent`) count as intent to click and run it, so a
-     * click after a hover needs no follow-up request. A document request and a
-     * navigation with no prefetch to adopt run it as usual.
+     * `prefetch: false` keeps this loader out of every `<Link>` prefetch: a
+     * prefetch (a partial request with `X-Rango-Prefetch`) does not execute
+     * it; the payload marks it deferred. `prefetch: "intent"` keeps it out of
+     * speculative prefetches only: a viewport or render prefetch
+     * (`X-Rango-Prefetch: 1`) defers it, and a hover prefetch or
+     * `useRouter().prefetch()` (`X-Rango-Prefetch: intent`) runs it, so a click
+     * after a hover needs no follow-up request for it. A document request and
+     * a navigation with no prefetch to adopt run it as usual.
      *
      * A deferred loader never blocks the navigation that adopts the prefetch:
      * it behaves like a loader that is still streaming. Its own `<Suspense>`
@@ -213,7 +215,7 @@ export type LoaderOptions = {
      * request only deferred work and middleware run, so values a held handler
      * would have set with `ctx.set()` are not visible.
      */
-    prefetch?: boolean;
+    prefetch?: PrefetchOption;
 };
 /**
  * Options for fetchable loaders

package/dist/types/urls/path-helper-types.d.ts

@@ -8,6 +8,7 @@ import type { ResponseHandler, ResponseHandlerContext, TextResponseHandler } fro
 import type { UnnamedRoute, LocalOnlyInclude, PathOptions, UrlPatterns, IncludeOptions } from "./pattern-types.js";
 import type { ExtractRoutes, ExtractResponses } from "./type-extraction.js";
 import type { ClientUrlPatterns } from "../client-urls/types.js";
+import type { PrefetchOption } from "../prefetch-markers.js";
 /**
  * Base path function signature for defining routes with URL patterns.
  */
@@ -161,10 +162,10 @@ export type PathHelpers<TEnv> = {
      * freezes into the shell (nested promises stay live holes) — the pre-flush
      * promise applied to the prelude.
      *
-     * Pass `{ prefetch: false }` to keep the loader out of speculative
-     * prefetches (viewport, render): such a prefetch skips it and the click
-     * that adopts it fetches it in one follow-up request; a hover prefetch runs
-     * it (see {@link LoaderOptions}). Only on a segment the
+     * Pass `{ prefetch: false }` to keep the loader out of prefetches: a
+     * prefetch skips it and the click that adopts it fetches it in one
+     * follow-up request. `{ prefetch: "intent" }` defers it in viewport and
+     * render prefetches only (see {@link LoaderOptions}). Only on a segment the
      * client does not have yet: a loader the client already holds runs in the
      * prefetch when it revalidates.
      */
@@ -173,9 +174,9 @@ export type PathHelpers<TEnv> = {
      * Attach a loading component to the current route/layout.
      *
      * `{ ssr: false }` skips the fallback on document requests. `{ prefetch:
-     * false }` keeps what the fallback covers out of viewport and render
-     * prefetches (a hover prefetch runs it), when this entry's segment is new
-     * to the client: the entry's handler, its loaders,
+     * false }` keeps what the fallback covers out of prefetches (`"intent"`:
+     * viewport and render prefetches only, see {@link LoaderOptions}), when this
+     * entry's segment is new to the client: the entry's handler, its loaders,
      * its orphan layouts and parallel slots and, for a layout, every deeper
      * entry. The click that adopts the prefetch shows the fallback and fetches
      * them in one follow-up request, which reads cache() and "use cache" as
@@ -189,7 +190,7 @@ export type PathHelpers<TEnv> = {
      */
     loading: (component: ReactNode | (() => ReactNode), options?: {
         ssr?: boolean;
-        prefetch?: boolean;
+        prefetch?: PrefetchOption;
     }) => LoadingItem;
     /**
      * Attach an error boundary to catch errors in this segment

package/dist/vite/index.js

@@ -111,6 +111,17 @@ var init_debug = __esm({
   }
 });
 
+// src/prefetch-markers.ts
+var PREFETCH_HEADER, PREFETCH_INTENT, PREFETCH_FAILED_ROW;
+var init_prefetch_markers = __esm({
+  "src/prefetch-markers.ts"() {
+    "use strict";
+    PREFETCH_HEADER = "X-Rango-Prefetch";
+    PREFETCH_INTENT = "intent";
+    PREFETCH_FAILED_ROW = ":H_0\n";
+  }
+});
+
 // src/internal-debug.ts
 var INTERNAL_RANGO_DEBUG;
 var init_internal_debug = __esm({
@@ -725,17 +736,6 @@ var init_validate_redirect_origin = __esm({
   }
 });
 
-// src/prefetch-markers.ts
-var PREFETCH_HEADER, PREFETCH_INTENT, PREFETCH_FAILED_ROW;
-var init_prefetch_markers = __esm({
-  "src/prefetch-markers.ts"() {
-    "use strict";
-    PREFETCH_HEADER = "X-Rango-Prefetch";
-    PREFETCH_INTENT = "intent";
-    PREFETCH_FAILED_ROW = ":H_0\n";
-  }
-});
-
 // src/browser/response-adapter.ts
 function isForeignRouterId(response, expectedId) {
   const got = response.headers.get("X-RSC-Router-Id");
@@ -4594,6 +4594,9 @@ import * as React4 from "react";
 // src/server/context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
+// src/errors.ts
+init_prefetch_markers();
+
 // src/cache/cache-key-utils.ts
 function routerKeyPrefix(routerId2) {
   return `${encodeURIComponent(routerId2)}@`;
@@ -5203,12 +5206,15 @@ import {
 } from "react";
 
 // src/loader-store.ts
+var NO_ROUTE_DATA = /* @__PURE__ */ new Set();
 var EMPTY_SNAPSHOT = Object.freeze({
   value: void 0,
   hasValue: false,
   error: null,
   isLoading: false,
-  requestId: 0
+  requestId: 0,
+  valueFor: NO_ROUTE_DATA,
+  requestFor: NO_ROUTE_DATA
 });
 
 // src/router/route-trie-builder.ts
@@ -5360,6 +5366,9 @@ function insertSegments(node, segments, index, leafBase, paramNames) {
   }
 }
 
+// src/client-urls/client-urls.ts
+init_prefetch_markers();
+
 // src/browser/react/use-navigation.ts
 import { useContext as useContext9, useEffect as useEffect7, useRef as useRef5 } from "react";
 
@@ -5921,6 +5930,9 @@ import { jsx as jsx9 } from "react/jsx-runtime";
 // src/server/root-layout.tsx
 import { Fragment as Fragment3, jsx as jsx10 } from "react/jsx-runtime";
 
+// src/route-definition/dsl-helpers.ts
+init_prefetch_markers();
+
 // src/prerender.ts
 var PRERENDER_PASSTHROUGH = Object.freeze({
   __brand: "prerenderPassthrough"
@@ -6315,8 +6327,13 @@ function serializeLoaderOptions(loaders, owner, options) {
     loaders,
     ({ prefetch }) => prefetch === false
   );
+  const intentLoaderIndices = indicesWhere(
+    loaders,
+    ({ prefetch }) => prefetch === "intent"
+  );
   return {
     ...deferrableLoaderIndices.length > 0 ? { deferrableLoaderIndices: Object.freeze(deferrableLoaderIndices) } : {},
+    ...intentLoaderIndices.length > 0 ? { intentLoaderIndices: Object.freeze(intentLoaderIndices) } : {},
     ...loaderRevalidate.some((keys) => keys.length > 0) ? {
       loaderRevalidate: Object.freeze(
         loaderRevalidate.map((keys) => Object.freeze(keys))
@@ -7327,7 +7344,7 @@ function resolveVersionsFrom(table, routerId2) {
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.33.1",
+  version: "0.34.0",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/skills/app-structure/large-app.md

@@ -706,6 +706,9 @@ Rules of thumb:
   never become clicks: activity feeds, analytics panels, reviews below the
   fold, a list behind a tab.
 - Do not flag what the likely click needs first: the page's main content.
+- Flag a loader worth starting on hover `prefetch: "intent"` instead: viewport
+  and render prefetches skip it, and a hover or `useRouter().prefetch()` runs
+  it, so that click needs no fill for it.
 - Read a flagged loader inside its own `<Suspense>`; with no boundary, React
   keeps the page being left on screen until the fill answers.
 - A same-route click (`/app/projects/1` to `/app/projects/2`) prefetches a

package/skills/client-urls/SKILL.md

@@ -132,7 +132,7 @@ flow into the generated route map, so `href()`, `ctx.reverse()` and
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `path()`       | Options are `name`, `search`, `trailingSlash`, `ppr` (shell caching — see `/ppr` → The loader lane rule); no response variants. Use callback may contain `loader()`, `loading()`, `transition()` |
 | `layout()`     | `layout(Component, () => [...])` — children are required and must contain at least one `path()`; may also hold `loader()`, `loading()`, `intercept()`, nested `layout()`                         |
-| `loader()`     | `loader(Def, use?)` or `loader(Def, { ssr: false, prefetch: false }, use?)` — see below                                                                                                          |
+| `loader()`     | `loader(Def, use?)` or `loader(Def, { ssr: false, prefetch: false \| "intent" }, use?)` — see below                                                                                              |
 | `loading()`    | Route-level boundary around the optimistic render; inline `<Suspense>` at read sites keeps the destination's chrome visible while only the reads wait                                            |
 | `revalidate()` | Valid **inside a loader() use callback only**; runs on the server (the build hoists it out of the `"use client"` module)                                                                         |
 | `transition()` | Inside a `path()` use callback only (at most one). ViewTransition config plus a browser-run `when` predicate (see `/view-transitions`); same-route navs in a group already hold without it       |
@@ -623,25 +623,27 @@ shell, such as a `useActionState` form (React suspends it once to encode its
 action), is in the first flush too: the router gives React up to three more
 turns before it, and none when the document is already complete.
 
-## `prefetch: false` — keep a loader out of speculative prefetches
+## `prefetch: false` — keep a loader out of prefetches
 
 A `<Link>` prefetch of a group route runs its loaders. Flag the expensive one
-and a viewport or render prefetch skips it. A hover prefetch, and
-`useRouter().prefetch()`, is intent to click: it runs the loader, and the
-click sends no fill (`/loader` → "`prefetch: false`").
+`prefetch: false` and every prefetch skips it. Flag it `prefetch: "intent"`
+and only a viewport or render prefetch skips it: a hover prefetch, and
+`useRouter().prefetch()`, is intent to click, runs it, and the click sends
+no fill for it (`/loader` → "`prefetch: false`").
 
 ```tsx
 path("/product/:slug", ProductPage, { name: "product" }, () => [
   loader(PriceLoader),
-  loader(ReviewsLoader, { prefetch: false }), // kept out of viewport prefetches
+  loader(RelatedLoader, { prefetch: "intent" }), // kept out of viewport prefetches
+  loader(ReviewsLoader, { prefetch: false }), // kept out of every prefetch
   loading(<ProductSkeleton />),
 ]),
 ```
 
 A click inside the group still shows the destination at once. With a
-viewport or render prefetch received, the URL and the other loaders' data move with the click
+prefetch received, the URL and the other loaders' data move with the click
 too, `useOutlet().pending` ends with that commit, and one follow-up request
-(the fill) runs only the flagged loaders. Read the flagged loader inside its
+(the fill) runs only the loaders it skipped. Read the flagged loader inside its
 own `<Suspense>` to show the page and that fallback at once; with no boundary
 React holds the page being left until the fill answers, as it would with no
 prefetch. Same rules as on a server route (`/loader` → "`prefetch: false`"):
@@ -660,8 +662,9 @@ rest of the destination; otherwise it is held. A same-route click
 - `loading()` in `clientUrls()` takes no options, and a flagged `loading()`
   on a server layout above the group defers nothing for the group's routes.
 - On an `intercept()` loader the flag works as in `urls()`: an in-group
-  viewport or render prefetch of the intercept's target defers it, and the
-  click opens the modal at once with one fill for it; a hover's runs it.
+  prefetch of the intercept's target defers it, and the click opens the
+  modal at once with one fill for it; a hover's runs a loader marked
+  `"intent"`.
 - With `ssr: false` on a `ppr` group route the flag works as on a server
   route: deferred unless the prefetch serves the loader from a pin of a
   document-captured shell (`/ppr` → "`prefetch: false` on a `ppr` route").

package/skills/hooks/data.md

@@ -200,6 +200,11 @@ shared value lives as long as at least one component using that key is mounted.
 A persistent component (e.g. a header) keeps the value across navigations; a
 route-scoped component's value is reclaimed when it unmounts. Registered-loader
 reads (keyed or not) reset on navigation from fresh route data, as before.
+A refreshed value belongs to the route data of the readers on screen when
+`load()` was called: a reader that mounts on another page or on a new visit,
+or that a navigation brings new route data, shows that route data from its
+first frame, and a `load()` still in flight when you leave lands on no other
+page; Back onto the refreshed page shows the refresh again.
 
 **Refreshing multiple loaders together (`refreshGroup` + `useRefreshLoaders`)**:
 

package/skills/hooks/state.md

@@ -96,16 +96,17 @@ reads the entry on screen, not the one `history.state` already holds.
 Back/forward and state the server sets on a navigation
 (`ctx.setLocationState()`, `redirect(url, { state })`) follow the same rule.
 
-| What changes the state                                       | A reader gets it                                                 |
-| ------------------------------------------------------------ | ---------------------------------------------------------------- |
-| `<Link state>`, `router.push()` / `router.replace()`         | in the commit that shows the destination                         |
-| back/forward                                                 | in the commit that restores the entry (cached or refetched)      |
-| the server, on a navigation (`setLocationState`, a redirect) | in the commit that shows the destination                         |
-| the server, on a document load (a page load, a no-JS post)   | once the page has hydrated, as stored state                      |
-| a navigation the server answers with nothing to re-render    | with the new location: the page on screen is the entry's         |
-| `router.push(url, { revalidate: false })` (no server fetch)  | with the new location: the page does not change                  |
-| a server action's `setLocationState` (no navigation)         | when the action's response arrives, added to what readers show   |
-| `Def.write()` / `Def.delete()`                               | when the entry is next restored: back/forward to it, or a reload |
+| What changes the state                                          | A reader gets it                                                                         |
+| --------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `<Link state>`, `router.push()` / `router.replace()`            | in the commit that shows the destination                                                 |
+| back/forward                                                    | in the commit that restores the entry (cached or refetched)                              |
+| the server, on a navigation (`setLocationState`, a redirect)    | in the commit that shows the destination                                                 |
+| the server, on a document load (a page load, a no-JS post)      | once the page has hydrated, as stored state                                              |
+| a navigation the server answers with nothing to re-render       | with the new location: the page on screen is the entry's                                 |
+| `router.push(url, { revalidate: false })` (no server fetch)     | with the new location: the page does not change                                          |
+| a server action's `setLocationState` (no navigation)            | when the action's response arrives, added to what readers show                           |
+| `router.refresh()`, or another tab's action refreshing this one | in the commit that shows the refreshed page: what readers show, plus what the server set |
+| `Def.write()` / `Def.delete()`                                  | when the entry is next restored: back/forward to it, or a reload                         |
 
 Three consequences:
 
@@ -260,7 +261,8 @@ and hydrating, so SSR and hydration agree), then clears it from `history.state`
 `replaceState` in a `useEffect`. Every component reading the same flash
 definition sees the value, whenever it mounts, until the next navigation or
 back/forward commits its entry's state: an entry that carries no flash shows
-none. A server action's state does not end it. Pressing back/forward will not
+none. A server action's state does not end it, nor a refresh, which keeps it
+on screen without writing it back to the entry. Pressing back/forward will not
 re-show the flash since it was cleared.
 
 Set flash state from the server via `redirect()` with state (from a handler,

package/skills/intercept/SKILL.md

@@ -69,6 +69,7 @@ export const urlpatterns = urls(({ path, layout, intercept, loader, loading }) =
 | Click link `/shop/product/abc`                        | `<ProductModal />` in `@modal`, background preserved |
 | Direct URL `/shop/product/abc`, or a reload           | Full `<ProductPage />` page                          |
 | `router.refresh()`, or another tab's action           | Full `<ProductPage />` page, as a reload             |
+| Link inside the intercept to another intercepted URL  | That intercept, over the same source page            |
 | Back from the open intercept                          | The intercept closes; the source page stays          |
 | Back/Forward onto the intercept's entry               | The intercept over its source page                   |
 | The same, uncached, from a page other than the source | Full `<ProductPage />` page, as a document load      |
@@ -311,13 +312,16 @@ intercepted: it gets the full page.
 ### `prefetch: false` on an intercept's loaders
 
 `loader(Def, { prefetch: false })` inside `intercept()` keeps that loader out
-of a viewport or render prefetch of the target from the source page (a hover
-prefetch runs it, and its click opens the modal complete with no fill):
+of every prefetch of the target from the source page. `{ prefetch: "intent" }`
+keeps it out of viewport and render prefetches only: a hover prefetch runs
+it, and when every flagged loader of the modal is `"intent"` its click opens
+the modal complete with no fill:
 
 ```typescript
 intercept("@modal", "product", <ProductModal />, () => [
   loader(ProductLoader),
-  loader(ReviewsLoader, { prefetch: false }), // skipped in a viewport prefetch
+  loader(PhotosLoader, { prefetch: "intent" }), // skipped in a viewport prefetch, runs on hover
+  loader(ReviewsLoader, { prefetch: false }), // skipped in every prefetch
   loading(<ModalSkeleton />),
 ]);
 ```
@@ -330,7 +334,7 @@ click shows nothing until its response. The modal's loaders resolve together,
 so its `loading()` shows until the last one arrives. A handler that reads the
 flagged loader with `ctx.use()` before its first `await` (or one with no
 `loading()`) gets it run in the prefetch instead: one run, no fill for it.
-`loading(…, { prefetch: false })` inside `intercept()` defers nothing.
+A `prefetch` option on `loading()` inside `intercept()` defers nothing.
 
 A prefetch of a route an intercept targets, or one sent from such a route, is
 stored per source page, whether or not the intercept applies from that page

package/skills/links/SKILL.md

@@ -619,14 +619,15 @@ A prefetch is a navigation sent early (a partial request with an
 `X-Rango-Prefetch` header), and by default the server renders everything for
 it: every handler and every loader. That is the point, a click then commits
 without a request, but it is also forty renders for a grid of forty links.
-Keep the expensive part out of speculative (viewport, render) prefetches on
-the route, not on the link:
+Keep the expensive part out of prefetches on the route, not on the link:
 
 ```tsx
-// skip one loader
+// skip one loader in every prefetch
 loader(ReviewsLoader, { prefetch: false }),
 // skip what the fallback covers
 loading(<OrdersSkeleton />, { prefetch: false }),
+// skip it in viewport and render prefetches only: a hover runs it
+loader(RelatedLoader, { prefetch: "intent" }),
 ```
 
 A click that adopts such a prefetch commits what was prefetched, shows the
@@ -635,13 +636,15 @@ is new to the page is deferred: a segment already on screen (the layout of the
 section you are in, the route itself on `/product/a` to `/product/b`) is
 prefetched as usual.
 
-A hover prefetch is treated as intent and runs everything, flagged work
-included (`X-Rango-Prefetch: intent`, where a viewport or render prefetch
-sends `1`); so does `useRouter().prefetch()`. Its click commits complete with
-no extra request. A hover sends that request only when the link has no
-prefetch cached or in flight: on a viewport link whose prefetch has already
-answered, it sends nothing, and the click fetches the deferred part as above.
-See
+A hover prefetch is treated as intent (`X-Rango-Prefetch: intent`, where a
+viewport or render prefetch sends `1`); so is `useRouter().prefetch()`. It
+runs the work marked `prefetch: "intent"` and still skips the work marked
+`prefetch: false`, so on a route whose flags are all `"intent"` its click
+commits complete with no extra request. A hover sends that request only when
+the link has no prefetch cached or in flight: on a viewport link whose
+prefetch has already answered, it sends nothing, and the click fetches the
+deferred part as above. Middleware that skips side effects in prefetches
+should test for the header's presence, not for `=== "1"`. See
 `/loader` → "`prefetch: false`" and `/route` → "`loading()` options". To stop
 a link or a whole section from prefetching at all, use the `prefetch` prop or
 `data-prefetch-scope` above.
@@ -668,8 +671,8 @@ The answer is page-only (`x-rsc-prefetch-scope: source`) when:
 
 - An intercept targets the route, or the page that sent the prefetch,
   whether or not it applies here.
-- The answer defers a `prefetch: false` loader or `loading()` that the page
-  does not show yet (a viewport or render prefetch; a hover's defers nothing).
+- The answer defers a `prefetch: false` or `prefetch: "intent"` loader or
+  `loading()` that the page does not show yet.
 - A `revalidate()` on the target read `currentUrl` and kept its segment.
 - A `revalidate()` on the route, or on a segment inside its `path()`, read
   the page being left and kept the segment through the route's default