# PRNext 0.1.18: retained page state and a stronger production runtime PRNext 0.1.18-alpha improves what happens between pages, builds and deployments. You can return to a page with its form state intact, prioritize a real navigation and reuse more compilation work. On the server, shared caches and resource limits provide more control over the work admitted for each request. This release also adds a project creation command, support for the TypeScript 7 compiler installed in your application and an optional integration with the official React Compiler. The sections below explain the changes by use case, followed by the changelog and application checks. ## Start with a project you can run The prnext create command prepares a minimal App Router application with its files, development scripts and configuration. TypeScript is the default; --js creates a JavaScript project. The result gives you a consistent starting point for development, production builds and serving the application. Creation only accepts a missing or completely empty directory. It refuses to replace an existing project. The --no-install option writes files without installing dependencies or accessing the network, including when adding a project to a workspace with its own package manager. ```sh npx @thomas.f/prnext create my-app cd my-app npm run dev ``` These commands require PRNext 0.1.18-alpha or later. ## Return to a page without starting over In the App Router, PRNext retains inactive branches through React Activity. Returning to an authorized destination under the same mounted layout can restore component state, such as a selected filter, a partially completed form or an open panel. Effects stop while the branch is hidden. The default budget is four inactive branches for two minutes, shared across the relevant layouts. This is an entry and time limit, not a RAM guarantee. The navigationCache setting lets you adjust retention or disable it. Retained state remains subject to data freshness and authorization. Server Actions, router.refresh() and observed identity changes invalidate inactive branches. Back and forward navigation request fresh Flight before revealing a retained destination. After custom authentication, the application must trigger the appropriate refresh. A full document reload does not preserve drafts held only in memory. ## Prioritize the click and recover from a lost connection Prefetching triggered by hover, keyboard focus and touch takes priority over viewport scans. An actual navigation has priority over speculative work. Queues and concurrent prefetches are bounded; data saver, slow connections and hidden tabs restrict speculation. A link with prefetch={false} does not trigger prefetching on hover or focus either. When an App navigation GET fails because of the transport, PRNext can recover within a thirty-second budget and at most three attempts. The current page and its mounted state remain visible during recovery. A newer navigation cancels the older attempt, and reconnection requests fresh data with the current cookies instead of using a saved private response. Recovery never automatically replays a Server Action or another POST. A mutation may have completed even when its response was lost. The application remains responsible for checking the result before offering another action. This is not persistent offline support; the optional useOffline hook lets the application display its own connection indicator. ## Send Flight changes with a complete-response fallback App navigations can negotiate streaming differential Flight. When the browser has a reusable base, PRNext sends the differences needed to reconstruct the exact fresh response. Retained bases are bounded and tied to both the deployment and the authentication context. A missing, expired or incompatible base produces a complete Flight response. An invalid delta allows one retry without a delta for that navigation GET. Actions are not replayed. The goal is to avoid repeated bytes when the content supports reuse without making navigation depend on a cache hit. Buffers and retained bases have explicit limits. HTML and stream handling also avoid unnecessary aggregate binary copies. A server response still includes React rendering, application code and data access; differential transport does not promise the same improvement on every page. ## Enable React Compiler and inspect its actual decisions The reactCompiler option enables the bundled official React Compiler. It is disabled by default. The transform targets application browser components and the isolated server-rendering graph of App Client Components, in development and production. Server Components, Server Action modules, npm dependencies and the Pages server graph remain outside this transform. You can adopt the compiler gradually with compilationMode: annotation and the use memo directive. The use no memo directive excludes an individual function. The prnext compiler report identifies observed functions, optimization or skip decisions and the compiler’s reasons. It also distinguishes cached transform reuse. These are compilation decisions, not measurements of interface speed. Eligible JavaScript graphs are stored as binary metadata and content-addressed blobs. Checksums are verified; missing, corrupt or concurrently evicted entries become ordinary cache misses and are rebuilt. Production builds can shorten local CSS Module and animation names, compact internal exports and reuse shared chunks while preserving public interfaces. ## Use the TypeScript installed in your application PRNext supports TypeScript 7 through its official native executable when installed in the application with its platform dependencies. Production checks, prnext typecheck and development diagnostics use that compiler. PRNext does not download a compiler during a build. TypeScript 5 and 6 retain their compiler API integration. Checks do not emit application JavaScript and keep incremental compiler state in an owned temporary directory. New source files and configuration changes restart the corresponding watch generation. Typed route generation also supports native TypeScript and preserves JSONC comments when updating configuration. Each project still needs to account for TypeScript 7’s own language and configuration changes. ## Share eligible cache entries across processes A local cache is not enough when an application runs across several workers or instances. PRNext adds optional Redis adapters for eligible shared results. The Cache Components handler supports use cache results. The separate createRedisIncrementalCache adapter covers native HTML and ISR, fetch and unstable_cache. These storage roles are explicit: enabling one adapter does not automatically replace every cache. Redis remains an optional application dependency. A normal project and a project created with the new command do not require it. Shared regeneration uses leases to coordinate work and prevent an older producer from publishing after invalidation or expiry. The model preserves tags and binary values. The purpose is consistent coordination across processes while retaining application data eligibility and isolation rules. ## Keep open tabs coherent across deployments Every production artifact has a deployment identity. PRNext can retain immutable assets from earlier generations within age, generation-count and size limits. An already open tab can finish loading resources belonging to its code instead of receiving arbitrary replacements from the next deployment. Retention applies to eligible assets. It does not justify serving an old personalized response or replaying an action. Proxies and caches in front of PRNext must preserve the headers and variations required by the deployment protocol. The htmlOnly option also selects fully static, noninteractive App pages. Their production HTML retains styles, fonts and metadata without bootstrap scripts or a Flight payload. Client Components, Server Actions, interactive links and incompatible rendering features are rejected for selected routes. Entering one of these pages performs ordinary document navigation. This is an explicit mode and does not remove JavaScript from other pages. ## Bound admitted work and let requests finish The runtime strengthens request admission, waiting queues and response budgets so load cannot create unbounded work. Scheduling accounts for routes and leaves room for requests outside the busiest stream. Runtime profiles better account for CPU and memory limits visible in the environment. Workers can stop or be replaced without treating the end of an HTTP stream as the end of all associated work. Cache finalizers and tracked post-response tasks are included in draining. Blocked processes retain a shutdown bound, and worker recovery does not replay a request that may already have changed data. Retiring idle workers can reduce resources retained between periods of activity, with a wake-up cost on the next request. The native process and other services remain present. This runtime mechanism is separate from an entire application sleeping at a hosting provider. Benefits depend on traffic and application behavior; this release does not promise a general reduction in RAM. ## Inspect the code actually executed and loaded Instrumentation hooks support registration and request-error reporting in the supported Node, RSC and Edge environments. Optional OTLP HTTP JSON export correlates native HTTP, Node, RSC and fetch stages with the application’s OpenTelemetry context. Export queues are bounded, and telemetry failure does not change the application response. Initial JavaScript analysis includes imports awaited during hydration and dynamic chunks actually used by server rendering. Reports distinguish sampled paths, compression-specific sizes and incomplete coverage. Styles are associated more closely with the relevant routes. This lets you inspect what a particular page loads without treating the sum of all project assets as its initial payload. ## The 0.1.18 changelog Navigation brings together bounded App branch retention, GET recovery after connection loss, interaction-first prefetching and differential Flight transport. Navigation and prefetch stages remain optional: navigation(), prefetch() and ensureStatic define eligible phases with Cache Components without making private content reusable by another user. Compilation adds React Compiler and its decision report, native TypeScript 7 and binary storage for eligible graphs. Builds shorten local CSS identifiers and reuse shared chunks. On-demand compilation can materialize destinations after middleware and rewrites, retain the required parallel branches and leave unrelated routes cold. Production adds Redis adapters, deployment identity, bounded asset retention and htmlOnly routes. Parallel prerendering and finalizers are coordinated more carefully. Admission, queues, response buffers and worker lifecycle gain stronger controls. The Web renderer remains the default; the optional Node path supports comparisons on the same application. Reliability fixes include discovering source subdirectories after coalesced filesystem notifications, resolving metadata helpers and refreshing native TypeScript diagnostics. Navigation tests wait for an interactive page, while worker tests distinguish a valid slower startup from exceeding shutdown bounds. The new generator prepares scripts and files for a minimal App Router application. ## Validation and adoption in your application This article documents source commit 05a9ccd. Full validation passes on Linux, macOS and Windows, covering the Rust runtime, unit tests, types, integrations and browsers. Archives for all six platforms are built from that same commit. Twelve isolated installations check both dependency layouts, and eighteen lifecycle scenarios cover Node.js 22, 24 and 26. Next.js compatibility remains partial and this release remains an alpha. Check your routes, data access, forms and Server Actions, then build and run the production application. Adopt React Compiler, Redis, staged navigation and htmlOnly separately so you can observe their effects in your project. After updating the package, rebuild and restart the application. Use the guides bundled with the installed version to find its actual options. Performance results tied to another source snapshot are not a new benchmark of this commit. Measure CPU, RAM and wake-up time on your application before generalizing a gain. ## Sources [PRNext : changements depuis v0.1.17-alpha / Changes since v0.1.17-alpha](https://github.com/Lorkydey/PRNext/compare/v0.1.17-alpha...05a9ccd20e86a20698b4a37bdf6a6baa3411ceaf) [Changelog du code documenté / Changelog for the documented source](https://github.com/Lorkydey/PRNext/blob/05a9ccd20e86a20698b4a37bdf6a6baa3411ceaf/CHANGELOG.md) [Guides de compatibilité / Compatibility guides](https://github.com/Lorkydey/PRNext/blob/05a9ccd20e86a20698b4a37bdf6a6baa3411ceaf/packages/prnext/docs/ai/compatibility.md) [Validation multiplateforme / Cross-platform validation](https://github.com/Lorkydey/PRNext/actions/runs/40980719114) Published: 2026-10-30 Modified: 2026-10-30 Author: PRNext --- Language: en Canonical: https://prnext.dev/blog/prnext-0-1-18-navigation-build-production Index: https://prnext.dev/llms.txt