WasmGC Shared ArrayBuffer Memory Boundary Isolation in Micro-Frontends

Federated micro-frontends utilizing WebAssembly Garbage Collection (WasmGC) and SharedArrayBuffer must enforce strict linear memory isolation and host reference boundary encapsulation. Direct passing of WasmGC heap references (externref/anyref) or shared underlying linear buffers across federated boundaries introduces cross-origin memory leaks, thread contention, and non-deterministic GC teardown cycles. Inter-module communication must instead traverse structured message ports or isolated transient serialization buffers governed by explicit lifecycle ownership.

--- description: WasmGC Shared ArrayBuffer Memory Boundary Isolation in Micro-Frontends - Federated micro-frontends utilizing WebAssembly Garbage Collection (WasmGC) and SharedArrayBuffer must enforce strict linear memory isolation and host reference boundary encapsulation. Direct passing of WasmGC heap references (externref/anyref) or shared underlying linear buffers across federated boundaries introduces cross-origin memory leaks, thread contention, and non-deterministic GC teardown cycles. Inter-module communication must instead traverse structured message ports or isolated transient serialization buffers governed by explicit lifecycle ownership. globs: src/**/*.{ts,tsx,wasm.ts}, packages/**/src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/wasmgc-shared-arraybuffer-microfrontend-isolation" --- # WasmGC Shared ArrayBuffer Memory Boundary Isolation in Micro-Frontends > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Leaking SharedArrayBuffer References and GC External References Across Federated Module Boundaries ## System Constraints You are a Principal Engineer enforcing WasmGC SharedArrayBuffer Memory Boundary Isolation in Micro-Frontends. Mandate absolute isolation between federated module heaps. Never expose raw WebAssembly.Memory, SharedArrayBuffer instances, or direct WasmGC externref/anyref handles across micro-frontend boundaries. Require defensive serialization, strict Web Worker isolation for thread pools, and deterministic finalization via FinalizationRegistry and WeakRef for any non-blocking DOM interop bindings. ## Strict Guidelines - Engineers MUST ALWAYS isolate WebAssembly linear memory and WasmGC reference graphs inside dedicated worker scopes or sandboxed micro-frontend boundaries. - Engineers MUST NOT expose raw SharedArrayBuffer instances or WasmGC externref pointers to other micro-frontends via window globals, module federation exports, or shared event emitters. - Code SHOULD serialize cross-boundary payloads using structured cloning (MessagePort) or bounded zero-copy transferable ArrayBuffers instead of shared mutable views. - Services MUST manage host-to-Wasm lifecycle references using FinalizationRegistry and WeakRef to prevent host closures from pinning GC-managed WebAssembly allocations. - Components NEVER hold synchronous direct handles to remote micro-frontend Wasm instances; interactions must be encapsulated through an asynchronous typed interface adapter. ## Bad vs Good Implementations ### Cross-Boundary WasmGC and Shared Memory Exposure #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Directly exposing the SharedArrayBuffer and WasmGC external references breaks the memory boundary. Remote micro-frontends can corrupt memory offsets, cause race conditions without synchronization, and indefinitely retain WasmGC references in the host environment, causing cross-module memory leaks. ```typescript // ANTI-PATTERN: Exporting shared memory and raw GC reference handles across federated boundary export interface FederatedWasmModule { sharedBuffer: SharedArrayBuffer; rawGcInstance: WebAssembly.Instance; getGcRef: (id: string) => any; // Leaks externref directly into host/remote MFE } export const federatedWasmApi: FederatedWasmModule = { sharedBuffer: new SharedArrayBuffer(1024 * 64), rawGcInstance: null!, getGcRef(id: string) { // Remote modules mutating this SharedArrayBuffer corrupt heap alignments // and prevent WasmGC from collecting orphaned external references return (window as any).__MFE_WASM_EXTERNREFS__.get(id); } }; ``` #### Production Standard (Correct) > **Standard**: Linear memory is isolated strictly inside a dedicated Web Worker. Data exchange relies exclusively on transferable ArrayBuffers through structured postMessage APIs, preventing concurrent writes and eliminating uncollected WasmGC host references. ```typescript // PRODUCTION INVARIANT: Sandboxed memory boundary with message-driven transferable marshaling interface RemoteWasmBridge { executeTask(payload: Uint8Array): Promise<ArrayBuffer>; dispose(): void; } export class IsolatedWasmMfeClient implements RemoteWasmBridge { private readonly worker: Worker; private readonly registry: FinalizationRegistry<string>; private readonly pending = new Map<string, (res: ArrayBuffer) => void>(); constructor(workerUrl: URL) { this.worker = new Worker(workerUrl, { type: 'module' }); this.registry = new FinalizationRegistry((taskId) => { this.pending.delete(taskId); }); this.worker.onmessage = (event: MessageEvent<{ taskId: string; result: ArrayBuffer }>) => { const { taskId, result } = event.data; const resolver = this.pending.get(taskId); if (resolver) { this.pending.delete(taskId); resolver(result); } }; } async executeTask(payload: Uint8Array): Promise<ArrayBuffer> { const taskId = crypto.randomUUID(); const copy = new Uint8Array(payload.length); copy.set(payload); return new Promise((resolve) => { this.pending.set(taskId, resolve); // Transfer buffer ownership; never share SharedArrayBuffer across federated boundaries this.worker.postMessage({ taskId, buffer: copy.buffer }, [copy.buffer]); }); } dispose(): void { this.worker.terminate(); this.pending.clear(); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: WasmGC Shared ArrayBuffer Memory Boundary Isolation in Micro-Frontends

WasmGC Shared ArrayBuffer Memory Boundary Isolation in Micro-Frontends defines an industrial-grade behavioral standard for frontend engineering. Federated micro-frontends utilizing WebAssembly Garbage Collection (WasmGC) and SharedArrayBuffer must enforce strict linear memory isolation and host reference boundary encapsulation. Direct passing of WasmGC heap references (externref/anyref) or shared underlying linear buffers across federated boundaries introduces cross-origin memory leaks, thread contention, and non-deterministic GC teardown cycles. Inter-module communication must instead traverse structured message ports or isolated transient serialization buffers governed by explicit lifecycle ownership. 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: Leaking SharedArrayBuffer References and GC External References Across Federated Module Boundaries 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	Leaking SharedArrayBuffer References and GC External References Across Federated Module Boundaries	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 WebAssembly linear memory and WasmGC reference graphs inside dedicated worker scopes or sandboxed micro-frontend boundaries.

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.