Vite 6 Module Runner SSR Execution Context Isolation Standard

--- description: Vite 6 Module Runner SSR Execution Context Isolation Standard - Enforces strict execution context isolation for Vite 6 Module Runner instances during server-side rendering (SSR). Prevents cross-request global singleton bleeding, uncollected module cache accumulation, and race conditions by isolating module evaluation within ephemeral worker threads or isolated runner environments. globs: src/server/**/*.{ts,js}, server/**/*.{ts,js}, vite.config.{ts,js}, **/*ssr*.{ts,js} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/vite6-module-runner-ssr-execution-isolation-standard" --- # Vite 6 Module Runner SSR Execution Context Isolation Standard > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Reusing a single ModuleRunner instance or shared module cache across concurrent SSR requests ## System Constraints You are a Principal Software Architect enforcing the Vite 6 Module Runner Custom Execution Isolation Standard. You must mandate strict worker-thread execution boundary isolation for server-side rendering. Under no circumstances may a single ModuleRunner instance or in-memory module evaluation cache be shared across distinct HTTP request lifecycles without deterministic cache clearance and state segregation. ## Strict Guidelines - Engineers MUST ALWAYS isolate SSR module execution either inside dedicated Worker Thread pools or via scoped ModuleRunner instances with isolated Evaluators. - Engineers MUST NOT share a single ModuleRunner evaluation cache across concurrent incoming HTTP requests containing request-bound or global state. - Code MUST explicitly dispose of ephemeral ModuleRunner instances or flush scoped module caches using runner.clearCache() upon request termination to prevent memory accumulation. - Services MUST route concurrent render jobs through a bounded Piscina or Node.js Worker pool when running Vite 6 Module Runner in multi-tenant or concurrent traffic setups. - Components and server entrypoints NEVER access or store request-scoped metadata (auth tokens, user state, tenant IDs) in root module-level lexical scope singletons. ## Bad vs Good Implementations ### Module Runner Instantiation and Lifecycle Management #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Reusing a single global ServerModuleRunner instance across concurrent requests causes module-level state, singletons, and user contexts to leak between different HTTP clients, while modules remain cached indefinitely in memory. ```typescript import { createServer } from 'vite'; import { createServerModuleRunner } from 'vite/module-runner'; import type { Request, Response } from 'express'; const vite = await createServer({ server: { middlewareMode: true } }); // CRITICAL ANTI-PATTERN: Shared module runner across all concurrent requests. // Modifying top-level singletons or importing stateful modules will leak across tenants. const globalRunner = createServerModuleRunner(vite.environments.ssr); export async function handleRequest(req: Request, res: Response) { const { render } = await globalRunner.import('/src/entry-server.ts'); const html = await render(req.url); res.status(200).send(html); } ``` #### Production Standard (Correct) > **Standard**: Each request executes within an isolated ModuleRunner lifecycle, utilizing a clean evaluation instance and deterministically closing the runner to eradicate memory leaks and prevent cross-request contamination. ```typescript import { createServer } from 'vite'; import { createServerModuleRunner, ESModulesEvaluator } from 'vite/module-runner'; import type { Request, Response } from 'express'; const vite = await createServer({ server: { middlewareMode: true } }); export async function handleRequest(req: Request, res: Response) { // PRODUCTION INVARIANT: Per-request isolated runner with explicit evaluator and lifecycle clean-up const requestRunner = createServerModuleRunner(vite.environments.ssr, { evaluator: new ESModulesEvaluator(), hmr: false }); try { const { render } = await requestRunner.import('/src/entry-server.ts'); const html = await render(req.url, { user: req.user }); res.status(200).send(html); } finally { // Guarantee complete eviction of the isolated module tree to eliminate memory leaks await requestRunner.close(); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Vite 6 Module Runner SSR Execution Context Isolation Standard

Vite 6 Module Runner SSR Execution Context Isolation Standard defines an industrial-grade behavioral standard for frontend engineering. Enforces strict execution context isolation for Vite 6 Module Runner instances during server-side rendering (SSR). Prevents cross-request global singleton bleeding, uncollected module cache accumulation, and race conditions by isolating module evaluation within ephemeral worker threads or isolated runner environments. 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: Reusing a single ModuleRunner instance or shared module cache across concurrent SSR requests 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	Reusing a single ModuleRunner instance or shared module cache across concurrent SSR requests	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 isolate SSR module execution either inside dedicated Worker Thread pools or via scoped ModuleRunner instances with isolated Evaluators.

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.