Deterministic Optimistic State Reconciliation and Rollback Invariant

--- description: Deterministic Optimistic State Reconciliation and Rollback Invariant - Enforces deterministic reconciliation and transactional rollback of client optimistic states during aborted, timed-out, or failed React 19 Server Actions. Eliminates state tearing, uncoordinated multi-state resets, and cascading layout thrashing by mandating idiomatic use of useOptimistic alongside useActionState within transition boundaries. globs: src/**/*.{ts,tsx}, app/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/react-19-server-action-optimistic-reconciliation" --- # Deterministic Optimistic State Reconciliation and Rollback Invariant > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Ad-Hoc Imperative Optimistic State Management with Manual Rollbacks Triggering Layout Thrashing ## System Constraints You are a Principal Frontend Architect enforcing deterministic state reconciliation in React 19. Mandate transactional optimistic updates via React 19's native useOptimistic and useActionState APIs. Reject any ad-hoc optimistic patterns that employ manual useState toggles, uncoordinated catch-block resets, or synchronous DOM reads during rollback cycles that provoke cascading layout thrashing. ## Strict Guidelines - Engineers MUST ALWAYS bind optimistic state projections strictly to canonical server state using React 19's `useOptimistic` hook. - Engineers MUST ALWAYS execute Server Actions containing optimistic mutations within a concurrent transition boundary using `startTransition` or native form action handlers. - Engineers MUST NOT manage optimistic mutations using split `useState` flags (e.g., `isOptimistic`, `tempItem`) paired with manual rollbacks in imperative `try...catch` blocks. - Components NEVER read layout-triggering DOM properties (e.g., `getBoundingClientRect`, `offsetHeight`, `scrollTop`) synchronously inside or immediately following an action failure or rollback transition. - Code MUST ensure that aborted actions (via `AbortSignal` or unmount) cleanly propagate errors to the React Fiber reconciler to enable atomic rollback without intermediate layout frame commits. - Services and Server Actions MUST return typed Result tuples or throw structured serializable errors rather than mutating global/shared client stores directly. ## Bad vs Good Implementations ### Ad-hoc useState rollback with layout thrashing vs. React 19 useOptimistic reconciliation #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Manually maintaining optimistic state via `useState` and imperative `try...catch` rollback triggers uncoordinated re-renders. Querying layout properties (`scrollHeight`) in the error path causes forced synchronous reflow (layout thrashing) while leaving state synchronization vulnerable to concurrent action races or unmounted component leaks. ```typescript import React, { useState } from 'react'; import { updateItemTitleAction } from './actions'; export function ItemEditor({ item }: { item: { id: string; title: string } }) { const [title, setTitle] = useState(item.title); const [previousTitle, setPreviousTitle] = useState(item.title); const [isUpdating, setIsUpdating] = useState(false); async function handleSubmit(formData: FormData) { const newTitle = formData.get('title') as string; setPreviousTitle(title); setTitle(newTitle); // Anti-pattern: manual optimistic state setting setIsUpdating(true); try { await updateItemTitleAction(item.id, newTitle); } catch (err) { // Anti-pattern: imperative rollback causes state tearing & cascading layout thrashing setTitle(previousTitle); const el = document.getElementById(`item-${item.id}`); if (el) { console.error('Failed at scroll height:', el.scrollHeight); // Forced synchronous reflow } } finally { setIsUpdating(false); } } return ( <form action={handleSubmit} id={`item-${item.id}`}> <input name="title" value={title} onChange={(e) => setTitle(e.target.value)} /> <button type="submit" disabled={isUpdating}>Save</button> </form> ); } ``` #### Production Standard (Correct) > **Standard**: Leverages React 19's native `useOptimistic` bound directly to `useActionState` within a transition. If the Server Action is aborted or encounters a server error, the React Fiber reconciler automatically rolls back `optimisticTitle` to `state.title` atomically in a single render pass without DOM thrashing or manual reference tracking. ```typescript import React, { useActionState, useOptimistic, startTransition } from 'react'; import { updateItemTitleAction, type ActionResult } from './actions'; interface ItemState { id: string; title: string; error: string | null; } export function ItemEditor({ item }: { item: { id: string; title: string } }) { const [state, formAction, isPending] = useActionState< ItemState, FormData >(async (prevState, formData) => { const nextTitle = formData.get('title') as string; const result: ActionResult = await updateItemTitleAction(prevState.id, nextTitle); if (!result.success) { return { ...prevState, error: result.error }; } return { id: prevState.id, title: result.data.title, error: null }; }, { id: item.id, title: item.title, error: null }); const [optimisticTitle, setOptimisticTitle] = useOptimistic( state.title, (_current, pendingTitle: string) => pendingTitle ); function handleFormSubmit(formData: FormData) { startTransition(async () => { const pendingTitle = formData.get('title') as string; setOptimisticTitle(pendingTitle); await formAction(formData); }); } return ( <form action={handleFormSubmit}> <input name="title" defaultValue={optimisticTitle} key={state.title} // Reconciles cleanly on transactional rollback disabled={isPending} /> <button type="submit" disabled={isPending}>Save</button> {state.error && <p role="alert" className="text-red-500">{state.error}</p>} </form> ); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Deterministic Optimistic State Reconciliation and Rollback Invariant

Deterministic Optimistic State Reconciliation and Rollback Invariant defines an industrial-grade behavioral standard for frontend engineering. Enforces deterministic reconciliation and transactional rollback of client optimistic states during aborted, timed-out, or failed React 19 Server Actions. Eliminates state tearing, uncoordinated multi-state resets, and cascading layout thrashing by mandating idiomatic use of useOptimistic alongside useActionState within transition boundaries. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Ad-Hoc Imperative Optimistic State Management with Manual Rollbacks Triggering Layout Thrashing Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Ad-Hoc Imperative Optimistic State Management with Manual Rollbacks Triggering Layout Thrashing	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS bind optimistic state projections strictly to canonical server state using React 19's `useOptimistic` hook.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.