React 19 Server Component Tainted Value Boundary Enforcement

--- description: React 19 Server Component Tainted Value Boundary Enforcement - Enforces compiler- and runtime-verified data boundary invariants in React 19 and Next.js App Router applications using experimental_taintObjectReference and experimental_taintUniqueValue. Guarantees that raw data-access objects, secrets, and database records containing sensitive customer domain models cannot cross the React Server Component serialization boundary to the client. Mandates explicit Data Transfer Object (DTO) mapping and immediate tainting at the Data Access Layer (DAL). globs: src/data/**/*.ts, src/services/**/*.ts, src/db/**/*.ts, src/app/**/*.{ts,tsx}, src/components/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/react-19-taint-boundary-enforcement" --- # React 19 Server Component Tainted Value Boundary Enforcement > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Passing un-sanitized raw database entities, API tokens, or ORM model instances across the RSC serialization boundary to Client Components ## System Constraints You are a Principal Software Architect enforcing zero-leakage security boundaries across React Server Components (RSC) and Client Components in React 19. You must mandate that every raw database entity, ORM model (e.g., Prisma, Drizzle), and sensitive credential is automatically registered with `experimental_taintObjectReference` or `experimental_taintUniqueValue` immediately upon acquisition in the Data Access Layer (DAL). You must reject any direct transmission of untransformed domain entities across RSC-client boundaries and demand explicit, whitelist-only Data Transfer Objects (DTOs). ## Strict Guidelines - Engineers MUST ALWAYS invoke `experimental_taintObjectReference(errorMessage, object)` inside the Data Access Layer (DAL) immediately upon retrieving raw entities from the database or external secure services. - Engineers MUST ALWAYS invoke `experimental_taintUniqueValue(errorMessage, object, value)` on sensitive scalars (such as authorization tokens, hashed passwords, SSNs, credit card tokens, and cryptographic keys) before processing them in server contexts. - Engineers MUST NEVER import or invoke `server-only` Data Access Layer queries directly from Client Components or expose the raw database model return types via RSC props. - Code MUST map raw tainted records to strict, whitelisted public Data Transfer Objects (DTOs) before passing them as props to Client Components or returning them from Server Actions. - Services MUST declare `'server-only'` at the top of every file encapsulating database connections, secret management, or taint registrations to trigger build-time failures if accidentally imported by client modules. - Components NEVER accept raw database entity types (e.g., `User`, `Account`, `PaymentMethod`) as props; props MUST be typed as explicitly projected DTO interfaces (e.g., `UserProfileDTO`). ## Bad vs Good Implementations ### Enforcing Data Layer Tainting and Strict DTO Projection #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The raw database entity is passed directly to a Client Component. Even if the Client Component only renders the name, React serializes the entire object into the RSC payload transmitted over HTTP, leaking `passwordHash`, `ssn`, and internal tenant IDs to the browser. ```typescript import { db } from '@/db'; import { ClientUserProfile } from '@/components/ClientUserProfile'; // DAL without taint protection export async function getUser(userId: string) { return await db.user.findUnique({ where: { id: userId } }); } // RSC passes raw ORM record containing passwordHash and ssn to Client Component export default async function UserProfilePage({ params }: { params: { id: string } }) { const user = await getUser(params.id); if (!user) return <div>Not found</div>; return <ClientUserProfile user={user} />; } ``` #### Production Standard (Correct) > **Standard**: The raw record is tainted using `experimental_taintObjectReference` and `experimental_taintUniqueValue`. If any developer attempts to pass `user` directly to a Client Component, React throws an immediate runtime/build error. Data is safely projected through a whitelisted `UserProfileDTO`. ```typescript import 'server-only'; import { experimental_taintObjectReference, experimental_taintUniqueValue } from 'react'; import { db } from '@/db'; import { ClientUserProfile, type UserProfileDTO } from '@/components/ClientUserProfile'; export async function getUser(userId: string) { const user = await db.user.findUnique({ where: { id: userId } }); if (!user) return null; // Runtime & build-time invariant: prevent React from serializing the raw DB entity experimental_taintObjectReference( 'Do not pass raw DB User objects to the client. Project to UserProfileDTO first.', user ); experimental_taintUniqueValue( 'Do not expose user password hashes to the client.', user, user.passwordHash ); return user; } function toUserProfileDTO(user: NonNullable<Awaited<ReturnType<typeof getUser>>>): UserProfileDTO { return { id: user.id, displayName: user.displayName, avatarUrl: user.avatarUrl, }; } export default async function UserProfilePage({ params }: { params: { id: string } }) { const user = await getUser(params.id); if (!user) return <div>Not found</div>; const safeUser = toUserProfileDTO(user); return <ClientUserProfile user={safeUser} />; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: React 19 Server Component Tainted Value Boundary Enforcement

React 19 Server Component Tainted Value Boundary Enforcement defines an industrial-grade behavioral standard for frontend engineering. Enforces compiler- and runtime-verified data boundary invariants in React 19 and Next.js App Router applications using experimental_taintObjectReference and experimental_taintUniqueValue. Guarantees that raw data-access objects, secrets, and database records containing sensitive customer domain models cannot cross the React Server Component serialization boundary to the client. Mandates explicit Data Transfer Object (DTO) mapping and immediate tainting at the Data Access Layer (DAL). 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: Passing un-sanitized raw database entities, API tokens, or ORM model instances across the RSC serialization boundary to Client Components 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	Passing un-sanitized raw database entities, API tokens, or ORM model instances across the RSC serialization boundary to Client Components	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 invoke `experimental_taintObjectReference(errorMessage, object)` inside the Data Access Layer (DAL) immediately upon retrieving raw entities from the database or external secure services.

Engineers MUST ALWAYS invoke `experimental_taintObjectReference(errorMessage, object)` inside the Data Access Layer (DAL) immediately upon retrieving raw entities from the database or external secure services.

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.