@rangojs/router 0.34.1 → 0.35.0

package/skills/middleware/SKILL.md

@@ -381,7 +381,7 @@ middleware `ctx` passed in); under `cache()` loaders can still read it because a
 DSL loader re-runs on every hit (a `"use cache"` function a loader calls cannot,
 and a loader bound with its own `cache()` only with a `key()`, which switches
 the check off, so the key must include the value). On a `ppr` route only a
-loader without `ssr: false` that no handler awaits may read it: a read the shell
+loader without `ssr: "await"` that no handler awaits may read it: a read the shell
 capture waits for refuses the capture. A middleware `ctx` passed to a
 `"use cache"` function keys the call by host, pathname, params and search, plus
 the route name once the route is matched (a global middleware before `next()`
@@ -556,7 +556,7 @@ direct visit does. A shell keyed by the visitor's URL
 that URL.
 
 **Middleware only, by design.** `rewrite()` is a middleware tool. A route
-handler or a loader (any loader, `ssr: false` included) cannot rewrite: its
+handler or a loader (any loader, `ssr: "await"` included) cannot rewrite: its
 throw is an error whose message points you to route middleware. A rewrite
 that depends on data goes in the route's middleware, reading the data
 through a cached function the loader shares, so the lookup runs once:

package/skills/migrate-nextjs/SKILL.md

@@ -40,7 +40,7 @@ Common reasons to migrate:
   build-time rendering instead of mixing rendering and caching behind conventions.
   See: `/prerender`
 - **Partial prerendering, shipped** — the `ppr` path option caches a page's
-  HTML shell and resumes its holes per request: loaders without `ssr: false`,
+  HTML shell and resumes its holes per request: loaders without `ssr: "await"`,
   read under `loading()` or an inline `<Suspense>`. Handler output bakes into
   the shell. It maps to Next's `experimental_ppr`, stable and per-route, but
   holes come from loaders, not from any `<Suspense>`.
@@ -100,7 +100,7 @@ its call site with the real Rango API:
 `next/dynamic`'s `{ ssr: false }` keeps a component out of server rendering:
 render it only after mount in a `"use client"` component (a `useEffect` flag,
 with `React.lazy()` if its code should split out). Do not map it to
-`loader(L, { ssr: false })`, which does the opposite: the server settles that
+`loader(L, { ssr: "await" })`, which does the opposite: the server settles that
 loader before the first flush, and under `ppr` it bakes into the shell.
 
 If an import has no row here and no obvious Rango equivalent, stop and surface
@@ -533,7 +533,7 @@ function ProductPage(ctx: HandlerContext) {
   );
 }
 
-// Rango, live price: a loader without ssr: false, read with
+// Rango, live price: a loader without ssr: "await", read with
 // useLoader(LivePriceLoader) in a client component. loading() (or an inline
 // <Suspense> around the reader) is the hole boundary (/ppr → The loader lane
 // rule).
@@ -560,9 +560,9 @@ Differences that matter during migration:
   component, a nested promise in a handle it pushes, a loader it awaits — is
   awaited at capture (bounded by `ppr.captureTimeout`) and served frozen for
   the shell's lifetime; a shell HIT never runs a handler. Keep the parts that
-  must be fresh in loaders without `ssr: false`, read with `useLoader` under
-  `loading()` or an inline `<Suspense>`; inside an `ssr: false` loader, return
-  them as nested promises. For loaders, `ssr: false` (not `loading()`) selects
+  must be fresh in loaders without `ssr: "await"`, read with `useLoader` under
+  `loading()` or an inline `<Suspense>`; inside an `ssr: "await"` loader, return
+  them as nested promises. For loaders, `ssr: "await"` (not `loading()`) selects
   the lane — see `/ppr` → The loader lane rule.
 - **Shell freshness is explicit.** Next's PPR shell is fixed until the next
   build; Rango's has `ttl`/`swr`/`tags` per route, and `updateTag()` /
@@ -577,7 +577,7 @@ Differences that matter during migration:
   `ctx.request.headers`, a `{ cache: false }` variable, and `ctx.dynamic()` refuse it anywhere the
   capture waits: a handler, a promise it passes or pushes, an async component,
   a loader it awaits. Per-user reads must move into a live loader (no
-  `ssr: false`; a nested promise does not help). A normal `ctx.get()` value is
+  `ssr: "await"`; a nested promise does not help). A normal `ctx.get()` value is
   not guarded and bakes as the capturing request's value. The refusal surfaces
   at migration time, which is the point.
 - **A store is required.** PPR needs the app-level `createRouter({ cache })`
@@ -890,7 +890,7 @@ const HomePage: Handler<"home"> = (ctx) => {
 
 `generateMetadata({ params })` — DATA-derived, document-blocking metadata —
 maps to a Meta push from the LOADER that owns the data, plus
-`{ ssr: false }` for the blocking-until-in-head part:
+`{ ssr: "await" }` for the blocking-until-in-head part:
 
 ```typescript
 // Next.js: export async function generateMetadata({ params }) {
@@ -907,7 +907,7 @@ export const ProductLoader = createLoader(async (ctx) => {
 });
 
 path("/product/:slug", ProductPage, { name: "product" }, () => [
-  loader(ProductLoader, { ssr: false }),
+  loader(ProductLoader, { ssr: "await" }),
 ]);
 ```
 
@@ -1008,7 +1008,7 @@ See `/theme` for full API including system detection and cookie persistence.
 10. [ ] Convert loading/error files to `loading()` / `errorBoundary()`
 11. [ ] Migrate API routes to `path.json()` / `path.text()`
 12. [ ] Update metadata to use `Meta` handle + `<Html.Meta />` in document head
-        (`generateMetadata` → loader push + `{ ssr: false }`)
+        (`generateMetadata` → loader push + `{ ssr: "await" }`)
 13. [ ] Replace `next-themes` with `theme: true` in createRouter (see `/theme`)
 14. [ ] Map rendering-mode segment config: `revalidate = N` → `cache({ ttl })`,
         `force-static` → `Static()`/`Prerender()`, `experimental_ppr` → the

package/skills/migrate-react-router/SKILL.md

@@ -34,7 +34,7 @@ Common reasons to migrate:
 - **Live data layer** — `createLoader()` and `loader()` keep data fresh
   independently of cached UI. A route can serve cached segments while loaders
   still resolve live on every request (on a `ppr` route, a loader registered
-  with `ssr: false` bakes into the cached HTML shell instead; see `/ppr`).
+  with `ssr: "await"` bakes into the cached HTML shell instead; see `/ppr`).
   See: `/loader`, `/caching`, `/cache-guide`
 - **Explicit caching model** — `cache()` DSL, `revalidate()`, `use cache`, and
   custom cache stores make data and render caching a first-class part of the router.

package/skills/migrate-react-router/component-migration.md

@@ -153,9 +153,9 @@ const HomePage: Handler<"home"> = (ctx) => {
 
 RR's data-derived `meta({ data })` maps to the same push from the LOADER that
 owns the data — `ctx.use(Meta)({ title: data.name })` in the loader body, with
-`loader(Def, { ssr: false })` when the title must be in the SSR'd
+`loader(Def, { ssr: "await" })` when the title must be in the SSR'd
 head. See `/loader` → "Writing Handles from Loaders". The loader flag is
-unrelated to RR7's `ssr: false` (SPA mode), which has no route-wide Rango
+unrelated to RR7's `ssr: "await"` (SPA mode), which has no route-wide Rango
 equivalent: it makes the server settle that loader before the first flush.
 
 Add `<Html.Meta />` in the Document component's `<head>`:

package/skills/migrate-react-router/data-and-actions.md

@@ -48,8 +48,8 @@ Use it only when you need capabilities beyond what the handler provides:
   document loads, never an HTTP 302 — pre-stream 302s move to middleware)
 - **`meta({ data })` / `handle` exports** — data-derived page metadata becomes
   a handle push from the loader body (`ctx.use(Meta)({ title: data.name })`),
-  with `loader(L, { ssr: false })` when it must be in the SSR'd head (not
-  RR7's `ssr: false` SPA mode, which has no route-wide Rango equivalent: the
+  with `loader(L, { ssr: "await" })` when it must be in the SSR'd head (not
+  RR7's `ssr: "await"` SPA mode, which has no route-wide Rango equivalent: the
   loader flag makes the server settle that loader before the first flush)
 
 If the React Router loader just fetches data for its page component AND the

package/skills/migrate-react-router/route-mapping.md

@@ -141,10 +141,10 @@ The loader-shaped variant is equally valid — and closer to the RR module when
 the loader carried authority. A `createLoader()` body can throw `notFound()`
 for the missing product AND push the data-derived meta itself
 (`ctx.use(Meta)({ title: product.name })`); register it with
-`loader(ProductLoader, { ssr: false })` when the 404 status and
+`loader(ProductLoader, { ssr: "await" })` when the 404 status and
 title must be in the document deterministically (the flag makes the server
 settle that loader before the first flush; it is unrelated to RR7's
-`ssr: false` SPA mode, which has no route-wide Rango equivalent). See
+`ssr: "await"` SPA mode, which has no route-wide Rango equivalent). See
 `/loader` → "Loader Authority" and "Writing Handles from Loaders". (One RR
 habit that does NOT carry over: a loader `throw redirect()` is a client-side
 navigate on document loads, never an HTTP 302 — pre-stream 302s belong in

package/skills/parallel/SKILL.md

@@ -152,10 +152,10 @@ layout, and `Meta` keeps the last value per key, so the override wins.
 > just to reach a `ctx.use(Meta)` call: under `cache()` the slot's output is
 > stored with the segment, and on a `ppr` route it bakes into the shell and a
 > HIT replays it without running the slot. The loader can push `Meta` itself
-> (`/loader` → "Writing Handles from Loaders"). Without `ssr: false` the
+> (`/loader` → "Writing Handles from Loaders"). Without `ssr: "await"` the
 > loader runs per request, but on a `ppr` route its push is not in the
 > shell's `<head>` (it applies after hydration). Add
-> `loader(Def, { ssr: false })` when the meta must be in the SSR'd head; on a
+> `loader(Def, { ssr: "await" })` when the meta must be in the SSR'd head; on a
 > `ppr` route that bakes the push into the shell, and a HIT serves it without
 > running the loader when its value has no promises. Keep the `@meta` slot for
 > metadata that is NOT loader-derived (templates, static descriptions,