Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation & Graph Isolation

Enforces strict runtime Subresource Integrity (SRI) attestation and isolated module graph boundaries for dynamically federated remote micro-frontends under Vite 6 and Rolldown. Dynamic ESM imports bypass native browser script-tag integrity checks, creating critical supply chain attack vectors when loading external chunks into the host execution context. This guardrail mandates SHA-384/SHA-512 cryptographic verification of remote manifests and chunks via Web Crypto prior to module graph evaluation.

--- description: Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation & Graph Isolation - Enforces strict runtime Subresource Integrity (SRI) attestation and isolated module graph boundaries for dynamically federated remote micro-frontends under Vite 6 and Rolldown. Dynamic ESM imports bypass native browser script-tag integrity checks, creating critical supply chain attack vectors when loading external chunks into the host execution context. This guardrail mandates SHA-384/SHA-512 cryptographic verification of remote manifests and chunks via Web Crypto prior to module graph evaluation. globs: src/**/*.{ts,tsx}, vite.config.{ts,js}, packages/**/src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/vite6-rolldown-dynamic-mfe-sri-attestation-guardrail" --- # Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation & Graph Isolation > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Unvalidated Dynamic ESM Ingestion of Remote Micro-Frontend Chunks ## System Constraints You are a Principal Security Architect enforcing the Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation Guardrail. Dynamic remote imports under Vite 6 / Rolldown module federation must NEVER evaluate unverified remote ESM graphs directly into the host runtime. You must mandate pre-fetch cryptographic hashing using crypto.subtle against a signed remote entry manifest, enforce sandboxed module evaluation via verified Object/Blob URLs or CSP-bound dynamic loaders, and ensure clean revocation to prevent memory leaks and graph pollution. ## Strict Guidelines - Engineers MUST ALWAYS cryptographically verify remote ESM chunks against a signed remote entry manifest using Web Crypto API (SHA-384 or SHA-512) prior to execution. - Engineers MUST NOT use unconstrained dynamic imports (e.g., import(/* @vite-ignore */ remoteUrl)) to consume federated modules without runtime SRI attestation. - Module loaders MUST isolate the remote module graph and revoke temporary Blob or Object URLs immediately after successful module instantiation to prevent resource leaks. - Federated remote manifests MUST be signed with an asymmetric key pair or fetched over mTLS/pinned endpoints, with manifest signatures validated prior to chunk resolution. - Host containers MUST fail closed (throw AttestationError and trigger fallback UI) whenever a chunk hash mismatch, signature failure, or network tampering occurs. - Rolldown and Vite 6 build configurations MUST generate strict cross-origin chunk hashes and emit deterministic asset manifests compatible with runtime attestation guards. ## Bad vs Good Implementations ### Unsafe Dynamic Remote Import vs. Cryptographically Attested Dynamic Module Loader #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Directly loading dynamic remote modules via native import() bypasses HTML Subresource Integrity protections entirely. If the remote host or CDN is poisoned, malicious code executes with the full privileges of the host domain without any integrity verification. ```typescript export async function loadRemoteMicroFrontend(moduleUrl: string): Promise<any> { // CRITICAL VULNERABILITY: Dynamic ESM import bypasses browser SRI checks. // A compromised CDN or MitM proxy can inject arbitrary remote code directly // into the host application's Rolldown execution context. const remoteModule = await import(/* @vite-ignore */ moduleUrl); return remoteModule; } ``` #### Production Standard (Correct) > **Standard**: Fetches the raw remote bundle and calculates its SHA-384/SHA-512 hash via the Web Crypto API, comparing it against a verified manifest entry. Only after cryptographic attestation passes is a ephemeral Blob URL created, imported, and immediately revoked to isolate the module graph and eliminate external script tampering. ```typescript export interface RemoteEntryManifest { entryChunk: string; integrity: `sha384-${string}` | `sha512-${string}`; } export class AttestationError extends Error { constructor(message: string) { super(`[SRI Attestation Failure] ${message}`); this.name = 'AttestationError'; } } async function verifyChunkIntegrity(buffer: ArrayBuffer, expectedSri: string): Promise<void> { const [algorithm, expectedHash] = expectedSri.split('-') as ['sha384' | 'sha512', string]; const algoMap: Record<string, string> = { sha384: 'SHA-384', sha512: 'SHA-512' }; const webCryptoAlgo = algoMap[algorithm]; if (!webCryptoAlgo) { throw new AttestationError(`Unsupported algorithm: ${algorithm}`); } const digest = await crypto.subtle.digest(webCryptoAlgo, buffer); const base64Hash = btoa(String.fromCharCode(...new Uint8Array(digest))); if (base64Hash !== expectedHash) { throw new AttestationError(`Integrity mismatch! Expected: ${expectedHash}, Computed: ${base64Hash}`); } } export async function loadAttestedRemoteModule<T = unknown>( url: string, manifest: RemoteEntryManifest ): Promise<T> { const response = await fetch(url, { credentials: 'same-origin', mode: 'cors' }); if (!response.ok) { throw new AttestationError(`Failed to fetch remote asset: ${response.statusText}`); } const codeBuffer = await response.arrayBuffer(); await verifyChunkIntegrity(codeBuffer, manifest.integrity); const blob = new Blob([codeBuffer], { type: 'text/javascript' }); const blobUrl = URL.createObjectURL(blob); try { const moduleInstance = await import(/* @vite-ignore */ blobUrl); return moduleInstance as T; } finally { URL.revokeObjectURL(blobUrl); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation & Graph Isolation

Vite 6 Rolldown Dynamic Micro-Frontend SRI Attestation & Graph Isolation defines an industrial-grade behavioral standard for frontend engineering. Enforces strict runtime Subresource Integrity (SRI) attestation and isolated module graph boundaries for dynamically federated remote micro-frontends under Vite 6 and Rolldown. Dynamic ESM imports bypass native browser script-tag integrity checks, creating critical supply chain attack vectors when loading external chunks into the host execution context. This guardrail mandates SHA-384/SHA-512 cryptographic verification of remote manifests and chunks via Web Crypto prior to module graph evaluation. 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: Unvalidated Dynamic ESM Ingestion of Remote Micro-Frontend Chunks 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	Unvalidated Dynamic ESM Ingestion of Remote Micro-Frontend Chunks	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 cryptographically verify remote ESM chunks against a signed remote entry manifest using Web Crypto API (SHA-384 or SHA-512) prior to execution.

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.