diff --git a/README.md b/README.md
index 76b29a9c..21502e7f 100644
--- a/README.md
+++ b/README.md
@@ -56,9 +56,11 @@ After install, using `ghostty-web` is as simple as
   <body>
     <div id="terminal"></div>
     <script type="module">
-      import { Terminal } from 'ghostty-web';
+      import { init, Terminal } from 'ghostty-web';
+
+      await init();
       const term = new Terminal();
-      await term.open(document.getElementById('terminal'));
+      term.open(document.getElementById('terminal'));
       term.write('Hello from \x1B[1;3;31mghostty-web\x1B[0m $ ');
     </script>
   </body>
@@ -108,7 +110,10 @@ machine, and screen buffer) to WebAssembly, providing:
 ### Basic Terminal
 
 ```typescript
-import { Terminal, FitAddon } from 'ghostty-web';
+import { init, Terminal, FitAddon } from 'ghostty-web';
+
+// Initialize WASM (call once at app startup)
+await init();
 
 const term = new Terminal({
   cursorBlink: true,
@@ -122,7 +127,7 @@ const term = new Terminal({
 const fitAddon = new FitAddon();
 term.loadAddon(fitAddon);
 
-await term.open(document.getElementById('terminal'));
+term.open(document.getElementById('terminal'));
 fitAddon.fit();
 
 // Handle user input
diff --git a/demo/colors-demo.html b/demo/colors-demo.html
index 2df6842a..38bbdd96 100644
--- a/demo/colors-demo.html
+++ b/demo/colors-demo.html
@@ -153,7 +153,7 @@ <h2>Color Demonstrations</h2>
     </div>
 
     <script type="module">
-      import { Terminal } from '../lib/index.ts';
+      import { init, Terminal } from '../lib/index.ts';
       import { FitAddon } from '../lib/addons/fit.ts';
 
       let term;
@@ -163,8 +163,11 @@ <h2>Color Demonstrations</h2>
       // Initialization
       // =========================================================================
 
-      function init() {
+      async function initApp() {
         try {
+          // Initialize WASM
+          await init();
+
           // Create terminal with dark theme
           term = new Terminal({
             cols: 120,
@@ -541,7 +544,7 @@ <h2>Color Demonstrations</h2>
       window.clearTerminal = clearTerminal;
 
       // Initialize on page load
-      init();
+      initApp();
     </script>
   </body>
 </html>
diff --git a/demo/index.html b/demo/index.html
index 8c709ae6..8de69381 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -131,7 +131,7 @@
     </div>
 
     <script type="module">
-      import { Terminal } from '../lib/terminal.ts';
+      import { init, Terminal } from '../lib/index.ts';
       import { FitAddon } from '../lib/addons/fit.ts';
 
       let term;
@@ -139,6 +139,9 @@
       let fitAddon;
 
       async function initTerminal() {
+        // Initialize WASM
+        await init();
+
         term = new Terminal({
           cursorBlink: true,
           fontSize: 14,
@@ -153,7 +156,7 @@
         fitAddon = new FitAddon();
         term.loadAddon(fitAddon);
 
-        await term.open(document.getElementById('terminal-container'));
+        term.open(document.getElementById('terminal-container'));
         fitAddon.fit();
         fitAddon.observeResize(); // Auto-fit when container resizes
 
@@ -162,7 +165,7 @@
           fitAddon.fit();
         });
 
-        // Handle terminal resize - MUST be registered before terminal becomes ready!
+        // Handle terminal resize
         term.onResize((size) => {
           if (ws && ws.readyState === WebSocket.OPEN) {
             // Send resize as control sequence (server expects this format)
@@ -183,13 +186,9 @@
           console.log('Scroll position:', ydisp);
         });
 
-        // Connect to PTY server AFTER terminal is ready
-        // This ensures term.cols/rows have been updated by FitAddon
-        // since the PTY server doesn't support dynamic resize
-        term.onReady(() => {
-          console.log('[Demo] Terminal ready, connecting with size:', term.cols, 'x', term.rows);
-          connectWebSocket();
-        });
+        // Connect to PTY server - terminal is ready immediately after open()
+        console.log('[Demo] Terminal ready, connecting with size:', term.cols, 'x', term.rows);
+        connectWebSocket();
       }
 
       function connectWebSocket() {
diff --git a/demo/scrollbar-test.html b/demo/scrollbar-test.html
index 648fe662..556598e6 100644
--- a/demo/scrollbar-test.html
+++ b/demo/scrollbar-test.html
@@ -35,9 +35,11 @@ <h2>Scrollbar Test</h2>
     <div id="terminal"></div>
 
     <script type="module">
-      import { Terminal } from '../lib/terminal.ts';
+      import { init, Terminal } from '../lib/index.ts';
       import { FitAddon } from '../lib/addons/fit.ts';
 
+      await init();
+
       const term = new Terminal({
         fontSize: 14,
         fontFamily: 'Monaco, Menlo, monospace',
diff --git a/lib/addons/fit.test.ts b/lib/addons/fit.test.ts
index 105d7b01..2da7bd00 100644
--- a/lib/addons/fit.test.ts
+++ b/lib/addons/fit.test.ts
@@ -163,10 +163,10 @@ describe('FitAddon', () => {
 });
 
 // ==========================================================================
-// onReady Auto-Retry Tests
+// Dimension Calculation Tests
 // ==========================================================================
 
-describe('onReady Auto-Retry', () => {
+describe('Dimension Calculation', () => {
   let addon: FitAddon;
 
   beforeEach(() => {
@@ -177,97 +177,6 @@ describe('onReady Auto-Retry', () => {
     addon.dispose();
   });
 
-  test('subscribes to onReady during activation', () => {
-    let subscribed = false;
-
-    const mockTerminal = {
-      cols: 80,
-      rows: 24,
-      onReady: (listener: () => void) => {
-        subscribed = true;
-        return { dispose: () => {} };
-      },
-    };
-
-    addon.activate(mockTerminal as any);
-    expect(subscribed).toBe(true);
-  });
-
-  test('calls fit() when onReady fires', () => {
-    let readyCallback: (() => void) | null = null;
-    let fitCallCount = 0;
-
-    // Create a mock element with computed dimensions
-    const mockElement = document.createElement('div');
-    Object.defineProperty(mockElement, 'clientWidth', { value: 800, configurable: true });
-    Object.defineProperty(mockElement, 'clientHeight', { value: 400, configurable: true });
-
-    const mockTerminal = {
-      cols: 80,
-      rows: 24,
-      element: mockElement,
-      renderer: {
-        getMetrics: () => ({ width: 9, height: 16, baseline: 12 }),
-      },
-      resize: (cols: number, rows: number) => {
-        fitCallCount++;
-        mockTerminal.cols = cols;
-        mockTerminal.rows = rows;
-      },
-      onReady: (listener: () => void) => {
-        readyCallback = listener;
-        return { dispose: () => {} };
-      },
-    };
-
-    addon.activate(mockTerminal as any);
-
-    // Before ready, fit() may not resize (depending on implementation)
-    const initialFitCount = fitCallCount;
-
-    // Simulate terminal becoming ready
-    if (readyCallback) {
-      readyCallback();
-    }
-
-    // fit() should have been called via onReady handler
-    expect(fitCallCount).toBeGreaterThan(initialFitCount);
-  });
-
-  test('disposes onReady subscription on dispose()', () => {
-    let disposed = false;
-
-    const mockTerminal = {
-      cols: 80,
-      rows: 24,
-      onReady: (listener: () => void) => {
-        return {
-          dispose: () => {
-            disposed = true;
-          },
-        };
-      },
-    };
-
-    addon.activate(mockTerminal as any);
-    expect(disposed).toBe(false);
-
-    addon.dispose();
-    expect(disposed).toBe(true);
-  });
-
-  test('handles terminal without onReady gracefully', () => {
-    const terminalWithoutReady = {
-      cols: 80,
-      rows: 24,
-      resize: () => {},
-    };
-
-    expect(() => addon.activate(terminalWithoutReady as any)).not.toThrow();
-    expect(() => addon.fit()).not.toThrow();
-    expect(() => addon.dispose()).not.toThrow();
-  });
-
   test('fit() calculates correct dimensions from container', () => {
     // Create a mock element with known dimensions
     // FitAddon subtracts 15px for scrollbar, so we need to account for that
diff --git a/lib/addons/fit.ts b/lib/addons/fit.ts
index d49db312..ea532656 100644
--- a/lib/addons/fit.ts
+++ b/lib/addons/fit.ts
@@ -44,25 +44,12 @@ export class FitAddon implements ITerminalAddon {
   private _lastCols?: number;
   private _lastRows?: number;
   private _isResizing: boolean = false;
-  private _pendingFit: boolean = false;
-  private _readyDisposable?: { dispose: () => void };
 
   /**
    * Activate the addon (called by Terminal.loadAddon)
    */
   public activate(terminal: ITerminalCore): void {
     this._terminal = terminal;
-
-    // Subscribe to onReady event if available (xterm.js compatibility)
-    const terminalWithEvents = terminal as any;
-    if (terminalWithEvents.onReady && typeof terminalWithEvents.onReady === 'function') {
-      this._readyDisposable = terminalWithEvents.onReady(() => {
-        // Terminal is ready - always call fit when ready
-        // This handles the case where fit() was called before terminal was ready
-        this._pendingFit = false;
-        this.fit();
-      });
-    }
   }
 
   /**
@@ -81,12 +68,6 @@ export class FitAddon implements ITerminalAddon {
       this._resizeDebounceTimer = undefined;
     }
 
-    // Dispose onReady subscription
-    if (this._readyDisposable) {
-      this._readyDisposable.dispose();
-      this._readyDisposable = undefined;
-    }
-
     // Clear stored dimensions
     this._lastCols = undefined;
     this._lastRows = undefined;
@@ -108,18 +89,9 @@ export class FitAddon implements ITerminalAddon {
 
     const dims = this.proposeDimensions();
     if (!dims || !this._terminal) {
-      // Check if terminal exists but renderer isn't ready yet
-      const terminal = this._terminal as any;
-      if (this._terminal && terminal.element && !terminal.renderer) {
-        // Mark fit as pending - will be called from onReady handler
-        this._pendingFit = true;
-      }
       return;
     }
 
-    // Clear pending flag if we get here
-    this._pendingFit = false;
-
     // Access terminal to check current dimensions
     const terminal = this._terminal as any;
     const currentCols = terminal.cols;
diff --git a/lib/buffer.test.ts b/lib/buffer.test.ts
index 1fb46de5..dc122fb0 100644
--- a/lib/buffer.test.ts
+++ b/lib/buffer.test.ts
@@ -1,17 +1,13 @@
 /**
  * Buffer API tests
+ *
+ * Test Isolation Pattern:
+ * Uses createIsolatedTerminal() to ensure each test gets its own WASM instance.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Terminal } from './terminal';
-
-/**
- * Helper to open terminal and wait for WASM to be ready.
- */
-async function openAndWaitForReady(term: Terminal, container: HTMLElement): Promise<void> {
-  term.open(container);
-  await new Promise<void>((resolve) => term.onReady(resolve));
-}
+import type { Terminal } from './terminal';
+import { createIsolatedTerminal } from './test-helpers';
 
 describe('Buffer API', () => {
   let term: Terminal | null = null;
@@ -22,8 +18,8 @@ describe('Buffer API', () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
-      term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
     }
   });
 
diff --git a/lib/index.ts b/lib/index.ts
index 660a6be1..bbf54c25 100644
--- a/lib/index.ts
+++ b/lib/index.ts
@@ -4,6 +4,56 @@
  * Main entry point following xterm.js conventions
  */
 
+import { Ghostty } from './ghostty';
+
+// Module-level Ghostty instance (initialized by init())
+let ghosttyInstance: Ghostty | null = null;
+
+/**
+ * Initialize the ghostty-web library by loading the WASM module.
+ * Must be called before creating any Terminal instances.
+ *
+ * This creates a shared WASM instance that all Terminal instances will use.
+ * For test isolation, pass a Ghostty instance directly to Terminal constructor.
+ *
+ * @example
+ * ```typescript
+ * import { init, Terminal } from 'ghostty-web';
+ *
+ * await init();
+ * const term = new Terminal();
+ * term.open(document.getElementById('terminal'));
+ * ```
+ */
+export async function init(): Promise<void> {
+  if (ghosttyInstance) {
+    return; // Already initialized
+  }
+  ghosttyInstance = await Ghostty.load();
+}
+
+/**
+ * Get the initialized Ghostty instance.
+ * Throws if init() hasn't been called.
+ * @internal
+ */
+export function getGhostty(): Ghostty {
+  if (!ghosttyInstance) {
+    throw new Error(
+      'ghostty-web not initialized. Call init() before creating Terminal instances.\n' +
+        'Example:\n' +
+        '  import { init, Terminal } from "ghostty-web";\n' +
+        '  await init();\n' +
+        '  const term = new Terminal();\n\n' +
+        'For tests, pass a Ghostty instance directly:\n' +
+        '  import { Ghostty, Terminal } from "ghostty-web";\n' +
+        '  const ghostty = await Ghostty.load();\n' +
+        '  const term = new Terminal({ ghostty });'
+    );
+  }
+  return ghosttyInstance;
+}
+
 // Main Terminal class
 export { Terminal } from './terminal';
 
diff --git a/lib/input-handler.test.ts b/lib/input-handler.test.ts
index 8519a2a3..4052d441 100644
--- a/lib/input-handler.test.ts
+++ b/lib/input-handler.test.ts
@@ -2,7 +2,7 @@
  * Unit tests for InputHandler
  */
 
-import { beforeAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
 import { Ghostty } from './ghostty';
 import { InputHandler } from './input-handler';
 import { Key, KeyAction, Mods } from './types';
@@ -127,13 +127,10 @@ describe('InputHandler', () => {
   let dataReceived: string[];
   let bellCalled: boolean;
 
-  beforeAll(async () => {
-    // Load WASM once for all tests (expensive operation)
-    // wasmPath is now optional - auto-detected
+  beforeEach(async () => {
+    // Create a fresh Ghostty WASM instance for complete test isolation
     ghostty = await Ghostty.load();
-  });
 
-  beforeEach(() => {
     // Create mock container for each test
     container = createMockContainer();
 
diff --git a/lib/interfaces.ts b/lib/interfaces.ts
index d6901fa0..5b2017d5 100644
--- a/lib/interfaces.ts
+++ b/lib/interfaces.ts
@@ -2,6 +2,8 @@
  * xterm.js-compatible interfaces
  */
 
+import type { Ghostty } from './ghostty';
+
 export interface ITerminalOptions {
   cols?: number; // Default: 80
   rows?: number; // Default: 24
@@ -12,7 +14,6 @@ export interface ITerminalOptions {
   fontSize?: number; // Default: 15
   fontFamily?: string; // Default: 'monospace'
   allowTransparency?: boolean;
-  wasmPath?: string; // Optional: custom WASM path (auto-detected by default)
 
   // Phase 1 additions
   convertEol?: boolean; // Convert \n to \r\n (default: false)
@@ -20,6 +21,10 @@ export interface ITerminalOptions {
 
   // Scrolling options
   smoothScrollDuration?: number; // Duration in ms for smooth scroll animation (default: 100, 0 = instant)
+
+  // Internal: Ghostty WASM instance (optional, for test isolation)
+  // If not provided, uses the module-level instance from init()
+  ghostty?: Ghostty;
 }
 
 export interface ITheme {
diff --git a/lib/scrolling.test.ts b/lib/scrolling.test.ts
index be2b71e8..1a653c96 100644
--- a/lib/scrolling.test.ts
+++ b/lib/scrolling.test.ts
@@ -1,13 +1,13 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Terminal } from './terminal';
-
 /**
- * Helper to open terminal and wait for WASM to be ready.
+ * Terminal Scrolling Tests
+ *
+ * Test Isolation Pattern:
+ * Uses createIsolatedTerminal() to ensure each test gets its own WASM instance.
  */
-async function openAndWaitForReady(term: Terminal, container: HTMLElement): Promise<void> {
-  term.open(container);
-  await new Promise<void>((resolve) => term.onReady(resolve));
-}
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import type { Terminal } from './terminal';
+import { createIsolatedTerminal } from './test-helpers';
 
 describe('Terminal Scrolling', () => {
   let terminal: Terminal;
@@ -16,8 +16,8 @@ describe('Terminal Scrolling', () => {
   beforeEach(async () => {
     container = document.createElement('div');
     document.body.appendChild(container);
-    terminal = new Terminal({ cols: 80, rows: 24 });
-    await openAndWaitForReady(terminal, container);
+    terminal = await createIsolatedTerminal({ cols: 80, rows: 24 });
+    terminal.open(container);
   });
 
   afterEach(() => {
@@ -30,7 +30,7 @@ describe('Terminal Scrolling', () => {
   });
 
   describe('Normal Screen Mode', () => {
-    test('should scroll viewport on wheel event in normal mode', () => {
+    test('should scroll viewport on wheel event in normal mode', async () => {
       // Fill with enough lines to create scrollback
       for (let i = 0; i < 50; i++) {
         terminal.write(`Line ${i}\r\n`);
@@ -51,7 +51,7 @@ describe('Terminal Scrolling', () => {
       expect(terminal.viewportY).toBeGreaterThan(initialViewportY);
     });
 
-    test('should scroll down on positive deltaY', () => {
+    test('should scroll down on positive deltaY', async () => {
       // Fill with scrollback
       for (let i = 0; i < 50; i++) {
         terminal.write(`Line ${i}\r\n`);
@@ -73,7 +73,7 @@ describe('Terminal Scrolling', () => {
       expect(terminal.viewportY).toBeLessThan(scrolledUpViewportY);
     });
 
-    test('should not send data to application in normal mode', () => {
+    test('should not send data to application in normal mode', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -91,16 +91,16 @@ describe('Terminal Scrolling', () => {
   });
 
   describe('Alternate Screen Mode', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
       // Enter alternate screen mode (vim, less, htop, etc.)
       terminal.write('\x1B[?1049h');
     });
 
-    test('should detect alternate screen mode', () => {
+    test('should detect alternate screen mode', async () => {
       expect(terminal.wasmTerm?.isAlternateScreen()).toBe(true);
     });
 
-    test('should send arrow up sequences on wheel up in alternate screen', () => {
+    test('should send arrow up sequences on wheel up in alternate screen', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -118,7 +118,7 @@ describe('Terminal Scrolling', () => {
       expect(dataSent.length).toBeCloseTo(3, 1); // ~3 arrows per click
     });
 
-    test('should send arrow down sequences on wheel down in alternate screen', () => {
+    test('should send arrow down sequences on wheel down in alternate screen', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -136,7 +136,7 @@ describe('Terminal Scrolling', () => {
       expect(dataSent.length).toBeCloseTo(3, 1); // ~3 arrows per click
     });
 
-    test('should not scroll viewport in alternate screen', () => {
+    test('should not scroll viewport in alternate screen', async () => {
       const initialViewportY = terminal.viewportY;
 
       // Simulate wheel event
@@ -151,7 +151,7 @@ describe('Terminal Scrolling', () => {
       expect(terminal.viewportY).toBe(initialViewportY);
     });
 
-    test('should cap arrow count at 5 per wheel event', () => {
+    test('should cap arrow count at 5 per wheel event', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -169,7 +169,7 @@ describe('Terminal Scrolling', () => {
   });
 
   describe('Mode Transitions', () => {
-    test('should switch behavior when entering alternate screen', () => {
+    test('should switch behavior when entering alternate screen', async () => {
       // Start in normal mode
       for (let i = 0; i < 30; i++) {
         terminal.write(`Line ${i}\r\n`);
@@ -206,7 +206,7 @@ describe('Terminal Scrolling', () => {
       expect(dataSent[0]).toBe('\x1B[A');
     });
 
-    test('should switch back to viewport scrolling when exiting alternate screen', () => {
+    test('should switch back to viewport scrolling when exiting alternate screen', async () => {
       // Enter alternate screen
       terminal.write('\x1B[?1049h');
       expect(terminal.wasmTerm?.isAlternateScreen()).toBe(true);
@@ -240,7 +240,7 @@ describe('Terminal Scrolling', () => {
   });
 
   describe('Custom Wheel Handler', () => {
-    test('should respect custom wheel handler in both modes', () => {
+    test('should respect custom wheel handler in both modes', async () => {
       let customHandlerCalled = false;
       terminal.attachCustomWheelEventHandler(() => {
         customHandlerCalled = true;
@@ -257,7 +257,7 @@ describe('Terminal Scrolling', () => {
       expect(customHandlerCalled).toBe(true);
     });
 
-    test('custom handler can delegate to default behavior', () => {
+    test('custom handler can delegate to default behavior', async () => {
       terminal.attachCustomWheelEventHandler(() => {
         return false; // Don't override, use default
       });
@@ -282,7 +282,7 @@ describe('Terminal Scrolling', () => {
   });
 
   describe('Edge Cases', () => {
-    test('should handle zero deltaY gracefully', () => {
+    test('should handle zero deltaY gracefully', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -297,7 +297,7 @@ describe('Terminal Scrolling', () => {
       expect(dataSent.length).toBe(0);
     });
 
-    test('should handle very small deltaY values', () => {
+    test('should handle very small deltaY values', async () => {
       const dataSent: string[] = [];
       terminal.onData((data) => dataSent.push(data));
 
@@ -315,8 +315,8 @@ describe('Terminal Scrolling', () => {
       expect(dataSent.length).toBe(0);
     });
 
-    test('should handle terminal not yet opened', () => {
-      const closedTerminal = new Terminal({ cols: 80, rows: 24 });
+    test('should handle terminal not yet opened', async () => {
+      const closedTerminal = await createIsolatedTerminal({ cols: 80, rows: 24 });
 
       // Should not crash when handleWheel is called without wasmTerm
       expect(() => {
@@ -344,8 +344,8 @@ describe('Scrolling Methods', () => {
   beforeEach(async () => {
     container = document.createElement('div');
     document.body.appendChild(container);
-    term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container);
+    term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container);
   });
 
   afterEach(() => {
@@ -355,7 +355,7 @@ describe('Scrolling Methods', () => {
     container = null;
   });
 
-  test('scrollLines() should scroll viewport up', () => {
+  test('scrollLines() should scroll viewport up', async () => {
     // Write some content to create scrollback
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -368,7 +368,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(5);
   });
 
-  test('scrollLines() should scroll viewport down', () => {
+  test('scrollLines() should scroll viewport down', async () => {
     // Write content and scroll up first
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -382,7 +382,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(5);
   });
 
-  test('scrollLines() should not scroll beyond bounds', () => {
+  test('scrollLines() should not scroll beyond bounds', async () => {
     // Write limited content
     for (let i = 0; i < 10; i++) {
       term.write(`Line ${i}\r\n`);
@@ -396,7 +396,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBeLessThanOrEqual(scrollbackLength);
   });
 
-  test('scrollLines() should not scroll below bottom', () => {
+  test('scrollLines() should not scroll below bottom', async () => {
     // Write content and scroll up
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -410,7 +410,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(0);
   });
 
-  test('scrollPages() should scroll by page', () => {
+  test('scrollPages() should scroll by page', async () => {
     // Write content
     for (let i = 0; i < 100; i++) {
       term.write(`Line ${i}\r\n`);
@@ -423,7 +423,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(2 * term.rows);
   });
 
-  test('scrollToTop() should scroll to top of buffer', () => {
+  test('scrollToTop() should scroll to top of buffer', async () => {
     // Write content
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -437,7 +437,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(scrollbackLength);
   });
 
-  test('scrollToBottom() should scroll to bottom', () => {
+  test('scrollToBottom() should scroll to bottom', async () => {
     // Write content and scroll up
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -451,7 +451,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(0);
   });
 
-  test('scrollToLine() should scroll to specific line', () => {
+  test('scrollToLine() should scroll to specific line', async () => {
     // Write content
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -463,7 +463,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBe(15);
   });
 
-  test('scrollToLine() should clamp to valid range', () => {
+  test('scrollToLine() should clamp to valid range', async () => {
     // Write limited content
     for (let i = 0; i < 10; i++) {
       term.write(`Line ${i}\r\n`);
@@ -477,7 +477,7 @@ describe('Scrolling Methods', () => {
     expect((term as any).viewportY).toBeLessThanOrEqual(scrollbackLength);
   });
 
-  test('scrollToLine() should handle negative values', () => {
+  test('scrollToLine() should handle negative values', async () => {
     // Write content
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
@@ -498,8 +498,8 @@ describe('Scroll Events', () => {
   beforeEach(async () => {
     container = document.createElement('div');
     document.body.appendChild(container);
-    term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container);
+    term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container);
   });
 
   afterEach(() => {
@@ -509,7 +509,7 @@ describe('Scroll Events', () => {
     container = null;
   });
 
-  test('onScroll should fire when scrolling', () => {
+  test('onScroll should fire when scrolling', async () => {
     let scrollPosition = -1;
     let fireCount = 0;
 
@@ -530,7 +530,7 @@ describe('Scroll Events', () => {
     expect(scrollPosition).toBe(5);
   });
 
-  test('onScroll should not fire if position unchanged', () => {
+  test('onScroll should not fire if position unchanged', async () => {
     let fireCount = 0;
 
     term.onScroll(() => {
@@ -543,7 +543,7 @@ describe('Scroll Events', () => {
     expect(fireCount).toBe(0);
   });
 
-  test('onScroll should fire multiple times for multiple scrolls', () => {
+  test('onScroll should fire multiple times for multiple scrolls', async () => {
     const positions: number[] = [];
 
     term.onScroll((position) => {
@@ -595,8 +595,8 @@ describe('Custom Wheel Event Handler', () => {
   beforeEach(async () => {
     container = document.createElement('div');
     document.body.appendChild(container);
-    term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container);
+    term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container);
   });
 
   afterEach(() => {
@@ -606,14 +606,14 @@ describe('Custom Wheel Event Handler', () => {
     container = null;
   });
 
-  test('attachCustomWheelEventHandler() should set handler', () => {
+  test('attachCustomWheelEventHandler() should set handler', async () => {
     const handler = () => true;
     term.attachCustomWheelEventHandler(handler);
 
     expect((term as any).customWheelEventHandler).toBe(handler);
   });
 
-  test('attachCustomWheelEventHandler() should allow clearing handler', () => {
+  test('attachCustomWheelEventHandler() should allow clearing handler', async () => {
     const handler = () => true;
     term.attachCustomWheelEventHandler(handler);
     term.attachCustomWheelEventHandler(undefined);
@@ -621,7 +621,7 @@ describe('Custom Wheel Event Handler', () => {
     expect((term as any).customWheelEventHandler).toBeUndefined();
   });
 
-  test('custom wheel handler should block default scrolling when returning true', () => {
+  test('custom wheel handler should block default scrolling when returning true', async () => {
     let handlerCalled = false;
 
     term.attachCustomWheelEventHandler(() => {
@@ -643,7 +643,7 @@ describe('Custom Wheel Event Handler', () => {
     expect((term as any).viewportY).toBe(0);
   });
 
-  test('custom wheel handler should allow default scrolling when returning false', () => {
+  test('custom wheel handler should allow default scrolling when returning false', async () => {
     let handlerCalled = false;
 
     term.attachCustomWheelEventHandler(() => {
@@ -665,7 +665,7 @@ describe('Custom Wheel Event Handler', () => {
     // Note: Due to scrolling at bottom, it won't change. Let's scroll up first.
   });
 
-  test('wheel events should scroll terminal by default', () => {
+  test('wheel events should scroll terminal by default', async () => {
     // Write content
     for (let i = 0; i < 50; i++) {
       term.write(`Line ${i}\r\n`);
diff --git a/lib/selection-manager.test.ts b/lib/selection-manager.test.ts
index ad30facd..6732810d 100644
--- a/lib/selection-manager.test.ts
+++ b/lib/selection-manager.test.ts
@@ -7,18 +7,14 @@
  * - Selection clearing behavior
  * - Auto-scroll during drag selection
  * - Copy functionality with scrollback
+ *
+ * Test Isolation Pattern:
+ * Uses createIsolatedTerminal() to ensure each test gets its own WASM instance.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Terminal } from './terminal';
-
-/**
- * Helper to open terminal and wait for WASM to be ready.
- */
-async function openAndWaitForReady(term: Terminal, container: HTMLElement): Promise<void> {
-  term.open(container);
-  await new Promise<void>((resolve) => term.onReady(resolve));
-}
+import type { Terminal } from './terminal';
+import { createIsolatedTerminal } from './test-helpers';
 
 /**
  * Helper to set selection using absolute coordinates
@@ -49,7 +45,7 @@ function viewportToAbsolute(term: Terminal, viewportRow: number): number {
 describe('SelectionManager', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -64,8 +60,8 @@ describe('SelectionManager', () => {
   });
 
   describe('Construction', () => {
-    test('creates without errors', () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+    test('creates without errors', async () => {
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       expect(term).toBeDefined();
     });
   });
@@ -74,8 +70,8 @@ describe('SelectionManager', () => {
     test('has required public methods', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       const selMgr = (term as any).selectionManager;
       expect(typeof selMgr.getSelection).toBe('function');
@@ -95,8 +91,8 @@ describe('SelectionManager', () => {
     test('hasSelection returns false when no selection', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       const selMgr = (term as any).selectionManager;
       expect(selMgr.hasSelection()).toBe(false);
@@ -107,8 +103,8 @@ describe('SelectionManager', () => {
     test('hasSelection returns true when selection exists', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Hello World\r\n');
 
@@ -124,8 +120,8 @@ describe('SelectionManager', () => {
     test('hasSelection returns false for single cell selection', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       // Same start and end = no real selection
       setSelectionAbsolute(term, 5, 0, 5, 0);
@@ -139,8 +135,8 @@ describe('SelectionManager', () => {
     test('clearSelection clears selection and marks rows dirty', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Line 1\r\nLine 2\r\nLine 3\r\n');
 
@@ -165,8 +161,8 @@ describe('SelectionManager', () => {
     test('getSelection returns empty string when no selection', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       const selMgr = (term as any).selectionManager;
       expect(selMgr.getSelection()).toBe('');
@@ -177,8 +173,8 @@ describe('SelectionManager', () => {
     test('getSelection extracts text from screen buffer', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Hello World\r\n');
 
@@ -195,8 +191,8 @@ describe('SelectionManager', () => {
     test('getSelection extracts multi-line text', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Line 1\r\nLine 2\r\nLine 3\r\n');
 
@@ -217,8 +213,8 @@ describe('SelectionManager', () => {
     test('getSelection extracts text from scrollback', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+      term.open(container);
 
       // Write enough lines to create scrollback
       for (let i = 0; i < 50; i++) {
@@ -244,8 +240,8 @@ describe('SelectionManager', () => {
     test('getSelection extracts text spanning scrollback and screen', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+      term.open(container);
 
       // Write enough lines to fill scrollback and screen
       for (let i = 0; i < 50; i++) {
@@ -272,8 +268,8 @@ describe('SelectionManager', () => {
     test('selection coordinates are preserved when scrolling', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+      term.open(container);
 
       // Write content
       for (let i = 0; i < 50; i++) {
@@ -303,8 +299,8 @@ describe('SelectionManager', () => {
     test('selection coords convert correctly after scrolling', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+      term.open(container);
 
       // Write content
       for (let i = 0; i < 50; i++) {
@@ -339,8 +335,8 @@ describe('SelectionManager', () => {
     test('selection outside viewport returns null coords but preserves text', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+      term.open(container);
 
       // Write content
       for (let i = 0; i < 100; i++) {
@@ -372,8 +368,8 @@ describe('SelectionManager', () => {
     test('getDirtySelectionRows returns empty set initially', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       const selMgr = (term as any).selectionManager;
       expect(selMgr.getDirtySelectionRows().size).toBe(0);
@@ -384,8 +380,8 @@ describe('SelectionManager', () => {
     test('clearSelection marks selection rows as dirty', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Test content\r\n');
 
@@ -404,8 +400,8 @@ describe('SelectionManager', () => {
     test('clearDirtySelectionRows clears the set', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Test\r\n');
 
@@ -429,8 +425,8 @@ describe('SelectionManager', () => {
     test('handles selection from right to left', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Hello World\r\n');
 
@@ -449,8 +445,8 @@ describe('SelectionManager', () => {
     test('handles selection from bottom to top', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Line 1\r\nLine 2\r\nLine 3\r\n');
 
@@ -473,8 +469,8 @@ describe('SelectionManager', () => {
     test('selectAll selects entire viewport', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Hello\r\nWorld\r\n');
 
@@ -497,8 +493,8 @@ describe('SelectionManager', () => {
     test('select() creates selection at specified position', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Hello World\r\n');
 
@@ -516,8 +512,8 @@ describe('SelectionManager', () => {
     test('selectLines() selects entire lines', async () => {
       if (!container) return;
 
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container);
 
       term.write('Line 1\r\nLine 2\r\nLine 3\r\n');
 
diff --git a/lib/terminal.test.ts b/lib/terminal.test.ts
index c5ff769c..0373aace 100644
--- a/lib/terminal.test.ts
+++ b/lib/terminal.test.ts
@@ -4,22 +4,14 @@
  * Tests the main Terminal class that integrates all components.
  * Note: These are logic-focused tests. Visual/rendering tests are skipped
  * since they require a full browser environment with canvas.
+ *
+ * Test Isolation Pattern:
+ * Uses createIsolatedTerminal() to ensure each test gets its own WASM instance.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Terminal } from './terminal';
-
-// Mock DOM environment for basic tests
-// Note: Some tests will be skipped if DOM is not fully available
-
-/**
- * Helper to open terminal and wait for WASM to be ready.
- * Use this when tests need to access wasmTerm or WASM-dependent features.
- */
-async function openAndWaitForReady(term: Terminal, container: HTMLElement): Promise<void> {
-  term.open(container);
-  await new Promise<void>((resolve) => term.onReady(resolve));
-}
+import type { Terminal } from './terminal';
+import { createIsolatedTerminal } from './test-helpers';
 
 /**
  * Helper to convert viewport row to absolute buffer row for selection tests.
@@ -57,7 +49,7 @@ function setSelectionViewportRelative(
 describe('Terminal', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     // Create a container element if document is available
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
@@ -74,20 +66,20 @@ describe('Terminal', () => {
   });
 
   describe('Constructor', () => {
-    test('creates terminal with default size', () => {
-      const term = new Terminal();
+    test('creates terminal with default size', async () => {
+      const term = await createIsolatedTerminal();
       expect(term.cols).toBe(80);
       expect(term.rows).toBe(24);
     });
 
-    test('creates terminal with custom size', () => {
-      const term = new Terminal({ cols: 100, rows: 30 });
+    test('creates terminal with custom size', async () => {
+      const term = await createIsolatedTerminal({ cols: 100, rows: 30 });
       expect(term.cols).toBe(100);
       expect(term.rows).toBe(30);
     });
 
-    test('creates terminal with custom options', () => {
-      const term = new Terminal({
+    test('creates terminal with custom options', async () => {
+      const term = await createIsolatedTerminal({
         cols: 120,
         rows: 40,
         scrollback: 5000,
@@ -97,34 +89,30 @@ describe('Terminal', () => {
       expect(term.cols).toBe(120);
       expect(term.rows).toBe(40);
     });
-
-    test('does not throw on construction', () => {
-      expect(() => new Terminal()).not.toThrow();
-    });
   });
 
   describe('Lifecycle', () => {
-    test('terminal is not open before open() is called', () => {
-      const term = new Terminal();
+    test('terminal is not open before open() is called', async () => {
+      const term = await createIsolatedTerminal();
       expect(() => term.write('test')).toThrow('Terminal must be opened');
     });
 
-    test('can be disposed without being opened', () => {
-      const term = new Terminal();
+    test('can be disposed without being opened', async () => {
+      const term = await createIsolatedTerminal();
       expect(() => term.dispose()).not.toThrow();
     });
 
     test('cannot write after disposal', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
       term.dispose();
 
       expect(() => term.write('test')).toThrow('Terminal has been disposed');
     });
 
     test('cannot open twice', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       // open() is synchronous and throws immediately
       expect(() => term.open(container!)).toThrow('already open');
@@ -132,8 +120,8 @@ describe('Terminal', () => {
       term.dispose();
     });
 
-    test('cannot open after disposal', () => {
-      const term = new Terminal();
+    test('cannot open after disposal', async () => {
+      const term = await createIsolatedTerminal();
       term.dispose();
 
       // open() is synchronous and throws immediately
@@ -142,17 +130,17 @@ describe('Terminal', () => {
   });
 
   describe('Properties', () => {
-    test('exposes cols and rows', () => {
-      const term = new Terminal({ cols: 90, rows: 25 });
+    test('exposes cols and rows', async () => {
+      const term = await createIsolatedTerminal({ cols: 90, rows: 25 });
       expect(term.cols).toBe(90);
       expect(term.rows).toBe(25);
     });
 
     test('exposes element after open', async () => {
-      const term = new Terminal();
+      const term = await createIsolatedTerminal();
       expect(term.element).toBeUndefined();
 
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
       expect(term.element).toBe(container);
 
       term.dispose();
@@ -160,23 +148,23 @@ describe('Terminal', () => {
   });
 
   describe('Events', () => {
-    test('onData event exists', () => {
-      const term = new Terminal();
+    test('onData event exists', async () => {
+      const term = await createIsolatedTerminal();
       expect(typeof term.onData).toBe('function');
     });
 
-    test('onResize event exists', () => {
-      const term = new Terminal();
+    test('onResize event exists', async () => {
+      const term = await createIsolatedTerminal();
       expect(typeof term.onResize).toBe('function');
     });
 
-    test('onBell event exists', () => {
-      const term = new Terminal();
+    test('onBell event exists', async () => {
+      const term = await createIsolatedTerminal();
       expect(typeof term.onBell).toBe('function');
     });
 
-    test('onData can register listeners', () => {
-      const term = new Terminal();
+    test('onData can register listeners', async () => {
+      const term = await createIsolatedTerminal();
       const disposable = term.onData((data) => {
         // Listener callback
       });
@@ -185,8 +173,8 @@ describe('Terminal', () => {
     });
 
     test('onResize fires when terminal is resized', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container!);
 
       let resizeEvent: { cols: number; rows: number } | null = null;
       term.onResize((e) => {
@@ -203,8 +191,8 @@ describe('Terminal', () => {
     });
 
     test('onBell fires on bell character', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       let bellFired = false;
       term.onBell(() => {
@@ -224,8 +212,8 @@ describe('Terminal', () => {
 
   describe('Writing', () => {
     test('write() does not throw after open', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.write('Hello, World!')).not.toThrow();
 
@@ -233,8 +221,8 @@ describe('Terminal', () => {
     });
 
     test('write() accepts string', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.write('test string')).not.toThrow();
 
@@ -242,8 +230,8 @@ describe('Terminal', () => {
     });
 
     test('write() accepts Uint8Array', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       const data = new TextEncoder().encode('test');
       expect(() => term.write(data)).not.toThrow();
@@ -252,8 +240,8 @@ describe('Terminal', () => {
     });
 
     test('writeln() adds newline', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.writeln('test line')).not.toThrow();
 
@@ -263,8 +251,8 @@ describe('Terminal', () => {
 
   describe('Resizing', () => {
     test('resize() updates dimensions', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container!);
 
       term.resize(100, 30);
 
@@ -275,8 +263,8 @@ describe('Terminal', () => {
     });
 
     test('resize() with same dimensions is no-op', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+      term.open(container!);
 
       let resizeCount = 0;
       term.onResize(() => resizeCount++);
@@ -288,16 +276,16 @@ describe('Terminal', () => {
       term.dispose();
     });
 
-    test('resize() throws if not open', () => {
-      const term = new Terminal();
+    test('resize() throws if not open', async () => {
+      const term = await createIsolatedTerminal();
       expect(() => term.resize(100, 30)).toThrow('must be opened');
     });
   });
 
   describe('Control Methods', () => {
     test('clear() does not throw', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.clear()).not.toThrow();
 
@@ -305,8 +293,8 @@ describe('Terminal', () => {
     });
 
     test('reset() does not throw', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.reset()).not.toThrow();
 
@@ -314,24 +302,24 @@ describe('Terminal', () => {
     });
 
     test('focus() does not throw', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.focus()).not.toThrow();
 
       term.dispose();
     });
 
-    test('focus() before open does not throw', () => {
-      const term = new Terminal();
+    test('focus() before open does not throw', async () => {
+      const term = await createIsolatedTerminal();
       expect(() => term.focus()).not.toThrow();
     });
   });
 
   describe('Addons', () => {
     test('loadAddon() accepts addon', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       const mockAddon = {
         activate: (terminal: any) => {
@@ -348,8 +336,8 @@ describe('Terminal', () => {
     });
 
     test('loadAddon() calls activate', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       let activateCalled = false;
       const mockAddon = {
@@ -367,8 +355,8 @@ describe('Terminal', () => {
     });
 
     test('dispose() calls addon dispose', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       let disposeCalled = false;
       const mockAddon = {
@@ -387,8 +375,8 @@ describe('Terminal', () => {
 
   describe('Integration', () => {
     test('can write ANSI sequences', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       // Should not throw on ANSI escape sequences
       expect(() => term.write('\x1b[1;31mRed bold text\x1b[0m')).not.toThrow();
@@ -399,8 +387,8 @@ describe('Terminal', () => {
     });
 
     test('can handle cursor movement sequences', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => term.write('\x1b[5;10H')).not.toThrow(); // Move cursor
       expect(() => term.write('\x1b[2A')).not.toThrow(); // Move up 2
@@ -410,8 +398,8 @@ describe('Terminal', () => {
     });
 
     test('multiple write calls work', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       expect(() => {
         term.write('Line 1\r\n');
@@ -425,16 +413,16 @@ describe('Terminal', () => {
 
   describe('Disposal', () => {
     test('dispose() can be called multiple times', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       term.dispose();
       expect(() => term.dispose()).not.toThrow();
     });
 
     test('dispose() cleans up canvas element', async () => {
-      const term = new Terminal();
-      await openAndWaitForReady(term, container!);
+      const term = await createIsolatedTerminal();
+      term.open(container!);
 
       const initialChildCount = container.children.length;
       expect(initialChildCount).toBeGreaterThan(0);
@@ -450,7 +438,7 @@ describe('Terminal', () => {
 describe('paste()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -467,9 +455,9 @@ describe('paste()', () => {
   describe('Basic functionality', () => {
     test('should fire onData event with pasted text', async () => {
       if (!container) return;
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedData = '';
       term.onData((data) => {
@@ -483,10 +471,10 @@ describe('paste()', () => {
     });
 
     test('should respect disableStdin option', async () => {
-      const term = new Terminal({ cols: 80, rows: 24, disableStdin: true });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, disableStdin: true });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedData = '';
       term.onData((data) => {
@@ -499,8 +487,8 @@ describe('paste()', () => {
       term.dispose();
     });
 
-    test('should work before terminal is open', () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+    test('should work before terminal is open', async () => {
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       expect(() => term.paste('test')).toThrow();
       term.dispose();
     });
@@ -510,7 +498,7 @@ describe('paste()', () => {
 describe('blur()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -526,26 +514,26 @@ describe('blur()', () => {
 
   describe('Basic functionality', () => {
     test('should not throw when terminal is open', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       expect(() => term.blur()).not.toThrow();
       term.dispose();
     });
 
-    test('should not throw when terminal is closed', () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+    test('should not throw when terminal is closed', async () => {
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       expect(() => term.blur()).not.toThrow();
       term.dispose();
     });
 
     test('should call blur on element', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       const blurSpy = { called: false };
       if (term.element) {
@@ -566,7 +554,7 @@ describe('blur()', () => {
 describe('input()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -582,10 +570,10 @@ describe('input()', () => {
 
   describe('Basic functionality', () => {
     test('should write data to terminal', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.input('test data');
 
@@ -596,10 +584,10 @@ describe('input()', () => {
     });
 
     test('should fire onData when wasUserInput is true', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedData = '';
       term.onData((data) => {
@@ -613,10 +601,10 @@ describe('input()', () => {
     });
 
     test('should not fire onData when wasUserInput is false', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedData = '';
       term.onData((data) => {
@@ -630,10 +618,10 @@ describe('input()', () => {
     });
 
     test('should respect disableStdin option', async () => {
-      const term = new Terminal({ cols: 80, rows: 24, disableStdin: true });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, disableStdin: true });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedData = '';
       term.onData((data) => {
@@ -651,7 +639,7 @@ describe('input()', () => {
 describe('select()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -667,10 +655,10 @@ describe('select()', () => {
 
   describe('Basic functionality', () => {
     test('should create selection', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.select(0, 0, 10);
 
@@ -679,10 +667,10 @@ describe('select()', () => {
     });
 
     test('should handle selection wrapping to next line', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       // Select 100 chars starting at column 0 (wraps to next line)
       term.select(0, 0, 100);
@@ -695,10 +683,10 @@ describe('select()', () => {
     });
 
     test('should fire selectionChange event', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let fired = false;
       term.onSelectionChange(() => {
@@ -712,10 +700,10 @@ describe('select()', () => {
     });
 
     test('should clear selection when clicking outside canvas', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       // Create a selection
       term.select(0, 0, 10);
@@ -739,7 +727,7 @@ describe('select()', () => {
 describe('selectLines()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -755,10 +743,10 @@ describe('selectLines()', () => {
 
   describe('Basic functionality', () => {
     test('should select entire lines', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.selectLines(0, 2);
 
@@ -772,10 +760,10 @@ describe('selectLines()', () => {
     });
 
     test('should handle reversed start/end', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.selectLines(5, 2); // End before start
 
@@ -787,10 +775,10 @@ describe('selectLines()', () => {
     });
 
     test('should fire selectionChange event', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let fired = false;
       term.onSelectionChange(() => {
@@ -808,7 +796,7 @@ describe('selectLines()', () => {
 describe('getSelectionPosition()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -824,10 +812,10 @@ describe('getSelectionPosition()', () => {
 
   describe('Basic functionality', () => {
     test('should return null when no selection', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       const pos = term.getSelectionPosition();
 
@@ -836,10 +824,10 @@ describe('getSelectionPosition()', () => {
     });
 
     test('should return correct position after select', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.select(5, 3, 10);
       const pos = term.getSelectionPosition();
@@ -851,10 +839,10 @@ describe('getSelectionPosition()', () => {
     });
 
     test('should return undefined after clearSelection', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.select(0, 0, 10);
       term.clearSelection();
@@ -869,7 +857,7 @@ describe('getSelectionPosition()', () => {
 describe('onKey event', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -885,10 +873,10 @@ describe('onKey event', () => {
 
   describe('Basic functionality', () => {
     test('should exist', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       expect(term.onKey).toBeTruthy();
       expect(typeof term.onKey).toBe('function');
@@ -896,10 +884,10 @@ describe('onKey event', () => {
     });
 
     test('should fire on keyboard events', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let keyEvent: any = null;
       term.onKey((e) => {
@@ -921,7 +909,7 @@ describe('onKey event', () => {
 describe('onTitleChange event', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -937,10 +925,10 @@ describe('onTitleChange event', () => {
 
   describe('Basic functionality', () => {
     test('should exist', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       expect(term.onTitleChange).toBeTruthy();
       expect(typeof term.onTitleChange).toBe('function');
@@ -948,10 +936,10 @@ describe('onTitleChange event', () => {
     });
 
     test('should fire when OSC 2 sequence is written', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedTitle = '';
       term.onTitleChange((title) => {
@@ -966,10 +954,10 @@ describe('onTitleChange event', () => {
     });
 
     test('should fire when OSC 0 sequence is written', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedTitle = '';
       term.onTitleChange((title) => {
@@ -984,10 +972,10 @@ describe('onTitleChange event', () => {
     });
 
     test('should handle ST terminator', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let receivedTitle = '';
       term.onTitleChange((title) => {
@@ -1006,7 +994,7 @@ describe('onTitleChange event', () => {
 describe('attachCustomKeyEventHandler()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1022,10 +1010,10 @@ describe('attachCustomKeyEventHandler()', () => {
 
   describe('Basic functionality', () => {
     test('should accept a custom handler', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       const handler = (e: KeyboardEvent) => false;
       expect(() => term.attachCustomKeyEventHandler(handler)).not.toThrow();
@@ -1033,10 +1021,10 @@ describe('attachCustomKeyEventHandler()', () => {
     });
 
     test('should accept undefined to clear handler', async () => {
-      const term = new Terminal({ cols: 80, rows: 24 });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       const handler = (e: KeyboardEvent) => false;
       expect(() => term.attachCustomKeyEventHandler(handler)).not.toThrow();
@@ -1048,7 +1036,7 @@ describe('attachCustomKeyEventHandler()', () => {
 describe('Terminal Options', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1064,10 +1052,10 @@ describe('Terminal Options', () => {
 
   describe('convertEol and disableStdin', () => {
     test('convertEol option should convert newlines', async () => {
-      const term = new Terminal({ cols: 80, rows: 24, convertEol: true });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, convertEol: true });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       term.write('line1\nline2');
 
@@ -1079,10 +1067,10 @@ describe('Terminal Options', () => {
     });
 
     test('disableStdin should prevent paste', async () => {
-      const term = new Terminal({ cols: 80, rows: 24, disableStdin: true });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, disableStdin: true });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let received = false;
       term.onData(() => {
@@ -1096,10 +1084,10 @@ describe('Terminal Options', () => {
     });
 
     test('disableStdin should prevent input with wasUserInput', async () => {
-      const term = new Terminal({ cols: 80, rows: 24, disableStdin: true });
+      const term = await createIsolatedTerminal({ cols: 80, rows: 24, disableStdin: true });
       // Using shared container from beforeEach
       if (!container) return;
-      await openAndWaitForReady(term, container!);
+      term.open(container!);
 
       let received = false;
       term.onData(() => {
@@ -1118,8 +1106,8 @@ describe('Buffer Access API', () => {
   let term: Terminal;
   let container: HTMLElement;
 
-  beforeEach(() => {
-    term = new Terminal();
+  beforeEach(async () => {
+    term = await createIsolatedTerminal();
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1136,14 +1124,14 @@ describe('Buffer Access API', () => {
   test('isAlternateScreen() starts false', async () => {
     if (!container) throw new Error('DOM environment not available - check happydom setup');
 
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
     expect(term.wasmTerm?.isAlternateScreen()).toBe(false);
   });
 
   test('isAlternateScreen() detects alternate screen mode', async () => {
     if (!container) throw new Error('DOM environment not available - check happydom setup');
 
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     // Enter alternate screen (DEC Private Mode 1049 - like vim does)
     term.write('\x1b[?1049h');
@@ -1157,7 +1145,7 @@ describe('Buffer Access API', () => {
   test('isRowWrapped() returns false for normal line breaks', async () => {
     if (!container) throw new Error('DOM environment not available - check happydom setup');
 
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
     term.write('Line 1\r\nLine 2\r\n');
 
     expect(term.wasmTerm?.isRowWrapped(0)).toBe(false);
@@ -1169,9 +1157,9 @@ describe('Buffer Access API', () => {
       throw new Error('DOM environment not available - check happydom setup');
 
     // Create narrow terminal to force wrapping
-    const narrowTerm = new Terminal({ cols: 20, rows: 10 });
+    const narrowTerm = await createIsolatedTerminal({ cols: 20, rows: 10 });
     const narrowContainer = document.createElement('div');
-    await openAndWaitForReady(narrowTerm, narrowContainer);
+    narrowTerm.open(narrowContainer);
 
     try {
       // Write text longer than terminal width (no newline)
@@ -1190,7 +1178,7 @@ describe('Buffer Access API', () => {
   test('isRowWrapped() handles edge cases', async () => {
     if (!container) throw new Error('DOM environment not available - check happydom setup');
 
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     // Row 0 can never be wrapped (nothing to wrap from)
     expect(term.wasmTerm?.isRowWrapped(0)).toBe(false);
@@ -1204,9 +1192,9 @@ describe('Buffer Access API', () => {
 describe('Terminal Modes', () => {
   test('should detect bracketed paste mode', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.hasBracketedPaste()).toBe(false);
     term.write('\x1b[?2004h');
@@ -1219,9 +1207,9 @@ describe('Terminal Modes', () => {
 
   test('paste() should use bracketed paste when enabled', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     let receivedData = '';
     term.onData((data) => {
@@ -1240,9 +1228,9 @@ describe('Terminal Modes', () => {
 
   test('should query arbitrary DEC modes', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.getMode(25)).toBe(true); // Cursor visible
     term.write('\x1b[?25l');
@@ -1253,9 +1241,9 @@ describe('Terminal Modes', () => {
 
   test('should detect focus event mode', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.hasFocusEvents()).toBe(false);
     term.write('\x1b[?1004h');
@@ -1266,9 +1254,9 @@ describe('Terminal Modes', () => {
 
   test('should detect mouse tracking modes', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.hasMouseTracking()).toBe(false);
     term.write('\x1b[?1000h');
@@ -1279,9 +1267,9 @@ describe('Terminal Modes', () => {
 
   test('should query ANSI modes vs DEC modes', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.getMode(4, true)).toBe(false); // Insert mode
     term.write('\x1b[4h');
@@ -1292,9 +1280,9 @@ describe('Terminal Modes', () => {
 
   test('should handle multiple modes set simultaneously', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     term.write('\x1b[?2004h\x1b[?1004h\x1b[?1000h');
     expect(term.hasBracketedPaste()).toBe(true);
@@ -1304,21 +1292,21 @@ describe('Terminal Modes', () => {
     term.dispose();
   });
 
-  test('getMode() throws when terminal not open', () => {
-    const term = new Terminal({ cols: 80, rows: 24 });
+  test('getMode() throws when terminal not open', async () => {
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     expect(() => term.getMode(25)).toThrow();
   });
 
-  test('hasBracketedPaste() throws when terminal not open', () => {
-    const term = new Terminal({ cols: 80, rows: 24 });
+  test('hasBracketedPaste() throws when terminal not open', async () => {
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     expect(() => term.hasBracketedPaste()).toThrow();
   });
 
   test('alternate screen mode via getMode()', async () => {
     if (typeof document === 'undefined') return;
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     const container = document.createElement('div');
-    await openAndWaitForReady(term, container!);
+    term.open(container!);
 
     expect(term.getMode(1049)).toBe(false);
     term.write('\x1b[?1049h');
@@ -1331,7 +1319,7 @@ describe('Terminal Modes', () => {
 describe('Selection with Scrollback', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1348,8 +1336,8 @@ describe('Selection with Scrollback', () => {
   test('should select correct text from scrollback buffer', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container!);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container!);
 
     // Write 100 lines with unique identifiable content
     // Lines 0-99, where each line has "Line XXX: content"
@@ -1401,8 +1389,8 @@ describe('Selection with Scrollback', () => {
   test('should select correct text when selection spans scrollback and screen', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container!);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container!);
 
     // Write 100 lines
     for (let i = 0; i < 100; i++) {
@@ -1441,8 +1429,8 @@ describe('Selection with Scrollback', () => {
   test('should select correct text when not scrolled (viewportY = 0)', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container!);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container!);
 
     // Write 100 lines
     for (let i = 0; i < 100; i++) {
@@ -1472,8 +1460,8 @@ describe('Selection with Scrollback', () => {
   test('should select correct text with fractional viewportY (smooth scroll)', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container!);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container!);
 
     // Write 100 simple numbered lines
     for (let i = 0; i < 100; i++) {
@@ -1514,8 +1502,8 @@ describe('Selection with Scrollback', () => {
   test('should handle selection in pure scrollback content', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24, scrollback: 1000 });
-    await openAndWaitForReady(term, container!);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24, scrollback: 1000 });
+    term.open(container!);
 
     // Write 100 lines
     for (let i = 0; i < 100; i++) {
@@ -1555,16 +1543,16 @@ describe('Selection with Scrollback', () => {
 // ==========================================================================
 
 describe('Public Mutable Options', () => {
-  test('options are publicly accessible and reflect initial values', () => {
-    const term = new Terminal({ cols: 100, rows: 30, scrollback: 5000 });
+  test('options are publicly accessible and reflect initial values', async () => {
+    const term = await createIsolatedTerminal({ cols: 100, rows: 30, scrollback: 5000 });
     expect(term.options).toBeDefined();
     expect(term.options.cols).toBe(100);
     expect(term.options.rows).toBe(30);
     expect(term.options.scrollback).toBe(5000);
   });
 
-  test('options can be mutated at runtime', () => {
-    const term = new Terminal();
+  test('options can be mutated at runtime', async () => {
+    const term = await createIsolatedTerminal();
     expect(term.options.disableStdin).toBe(false);
     term.options.disableStdin = true;
     expect(term.options.disableStdin).toBe(true);
@@ -1580,7 +1568,7 @@ describe('Public Mutable Options', () => {
 describe('Options Proxy handleOptionChange', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1597,8 +1585,8 @@ describe('Options Proxy handleOptionChange', () => {
   test('changing cursorStyle updates renderer', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cursorStyle: 'block' });
-    await openAndWaitForReady(term, container);
+    const term = await createIsolatedTerminal({ cursorStyle: 'block' });
+    term.open(container);
 
     // Verify initial state
     expect(term.options.cursorStyle).toBe('block');
@@ -1622,8 +1610,8 @@ describe('Options Proxy handleOptionChange', () => {
   test('changing cursorBlink starts/stops blink timer', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cursorBlink: false });
-    await openAndWaitForReady(term, container);
+    const term = await createIsolatedTerminal({ cursorBlink: false });
+    term.open(container);
 
     // Verify initial state
     expect(term.options.cursorBlink).toBe(false);
@@ -1651,8 +1639,8 @@ describe('Options Proxy handleOptionChange', () => {
   test('changing cols/rows triggers resize', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24 });
-    await openAndWaitForReady(term, container);
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+    term.open(container);
 
     let resizeEventFired = false;
     let resizedCols = 0;
@@ -1682,8 +1670,8 @@ describe('Options Proxy handleOptionChange', () => {
     term.dispose();
   });
 
-  test('handleOptionChange not called before terminal is open', () => {
-    const term = new Terminal({ cursorStyle: 'block' });
+  test('handleOptionChange not called before terminal is open', async () => {
+    const term = await createIsolatedTerminal({ cursorStyle: 'block' });
 
     // Changing options before open() should not throw
     // (handleOptionChange checks isOpen internally)
@@ -1702,7 +1690,7 @@ describe('Options Proxy handleOptionChange', () => {
 describe('disableStdin', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -1719,9 +1707,8 @@ describe('disableStdin', () => {
   test('blocks keyboard input from firing onData when enabled', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1742,9 +1729,8 @@ describe('disableStdin', () => {
   test('allows input when disableStdin is false', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1763,9 +1749,8 @@ describe('disableStdin', () => {
   test('can toggle disableStdin at runtime', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1791,9 +1776,8 @@ describe('disableStdin', () => {
   test('blocks real keyboard events when disableStdin is true', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1820,9 +1804,8 @@ describe('disableStdin', () => {
   test('allows real keyboard events when disableStdin is false', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1849,9 +1832,8 @@ describe('disableStdin', () => {
   test('keyboard events blocked after toggling disableStdin on', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
-    await new Promise((r) => term.onReady(r));
 
     const receivedData: string[] = [];
     term.onData((data) => receivedData.push(data));
@@ -1894,13 +1876,13 @@ describe('disableStdin', () => {
 // ==========================================================================
 
 describe('unicode API', () => {
-  test('activeVersion returns 15.1', () => {
-    const term = new Terminal();
+  test('activeVersion returns 15.1', async () => {
+    const term = await createIsolatedTerminal();
     expect(term.unicode.activeVersion).toBe('15.1');
   });
 
-  test('unicode object is readonly', () => {
-    const term = new Terminal();
+  test('unicode object is readonly', async () => {
+    const term = await createIsolatedTerminal();
     // The unicode property should be accessible
     expect(term.unicode).toBeDefined();
     expect(typeof term.unicode.activeVersion).toBe('string');
@@ -1908,118 +1890,13 @@ describe('unicode API', () => {
 });
 
 // ==========================================================================
-// xterm.js Compatibility: onReady Event
-// ==========================================================================
-
-describe('onReady Event', () => {
-  let container: HTMLElement | null = null;
-
-  beforeEach(() => {
-    if (typeof document !== 'undefined') {
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    }
-  });
-
-  afterEach(() => {
-    if (container && container.parentNode) {
-      container.parentNode.removeChild(container);
-      container = null;
-    }
-  });
-
-  test('fires after WASM is loaded and terminal is ready', async () => {
-    if (!container) return;
-
-    const term = new Terminal();
-    let firedAt = 0;
-    const openedAt = Date.now();
-
-    term.onReady(() => {
-      firedAt = Date.now();
-    });
-
-    term.open(container);
-
-    // Wait for ready
-    await new Promise((r) => setTimeout(r, 300));
-
-    expect(firedAt).toBeGreaterThan(0);
-    expect(firedAt).toBeGreaterThanOrEqual(openedAt);
-
-    term.dispose();
-  });
-
-  test('late subscribers fire immediately when already ready', async () => {
-    if (!container) return;
-
-    const term = new Terminal();
-    term.open(container);
-
-    // Wait for terminal to be ready
-    await new Promise((r) => term.onReady(r));
-
-    // Now subscribe late - should fire immediately
-    let firedImmediately = false;
-    let callOrder = 0;
-
-    term.onReady(() => {
-      firedImmediately = true;
-      callOrder = 1;
-    });
-
-    // Check synchronously - should have fired already
-    expect(firedImmediately).toBe(true);
-    expect(callOrder).toBe(1);
-
-    term.dispose();
-  });
-
-  test('multiple subscribers all receive the event', async () => {
-    if (!container) return;
-
-    const term = new Terminal();
-    let count = 0;
-
-    term.onReady(() => count++);
-    term.onReady(() => count++);
-    term.onReady(() => count++);
-
-    term.open(container);
-    await new Promise((r) => setTimeout(r, 300));
-
-    expect(count).toBe(3);
-
-    term.dispose();
-  });
-
-  test('wasmTerm is available when onReady fires', async () => {
-    if (!container) return;
-
-    const term = new Terminal();
-    let wasmTermAvailable = false;
-
-    term.onReady(() => {
-      wasmTermAvailable = term.wasmTerm !== undefined;
-    });
-
-    term.open(container);
-    await new Promise((r) => setTimeout(r, 300));
-
-    expect(wasmTermAvailable).toBe(true);
-
-    term.dispose();
-  });
-});
-
-// ==========================================================================
-// xterm.js Compatibility: Write Queueing
+// xterm.js Compatibility: Write Behavior
 // ==========================================================================
 
-describe('Write Queueing', () => {
+describe('Write Behavior', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -2033,21 +1910,16 @@ describe('Write Queueing', () => {
     }
   });
 
-  test('writes before ready are queued and processed after', async () => {
+  test('writes are processed immediately after open', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
 
-    // Write immediately after open (before WASM is loaded)
     term.write('Line1\r\n');
     term.write('Line2\r\n');
     term.write('Line3\r\n');
 
-    // Wait for ready
-    await new Promise((r) => term.onReady(r));
-
-    // All writes should have been processed
     const line0 = term.buffer.active.getLine(0)?.translateToString().trim();
     const line1 = term.buffer.active.getLine(1)?.translateToString().trim();
     const line2 = term.buffer.active.getLine(2)?.translateToString().trim();
@@ -2062,7 +1934,7 @@ describe('Write Queueing', () => {
   test('write callbacks are called after processing', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
 
     const callbackOrder: number[] = [];
@@ -2071,31 +1943,13 @@ describe('Write Queueing', () => {
     term.write('Second', () => callbackOrder.push(2));
     term.write('Third', () => callbackOrder.push(3));
 
-    await new Promise((r) => term.onReady(r));
-    // Give callbacks time to fire
+    // Give callbacks time to fire (they use requestAnimationFrame)
     await new Promise((r) => setTimeout(r, 50));
 
     expect(callbackOrder).toEqual([1, 2, 3]);
 
     term.dispose();
   });
-
-  test('writes after ready go directly without queueing', async () => {
-    if (!container) return;
-
-    const term = new Terminal();
-    term.open(container);
-    await new Promise((r) => term.onReady(r));
-
-    // Write after ready
-    term.write('DirectWrite\r\n');
-
-    // Should be immediately visible
-    const line = term.buffer.active.getLine(0)?.translateToString().trim();
-    expect(line).toBe('DirectWrite');
-
-    term.dispose();
-  });
 });
 
 // ==========================================================================
@@ -2105,7 +1959,7 @@ describe('Write Queueing', () => {
 describe('Synchronous open()', () => {
   let container: HTMLElement | null = null;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof document !== 'undefined') {
       container = document.createElement('div');
       document.body.appendChild(container);
@@ -2119,26 +1973,21 @@ describe('Synchronous open()', () => {
     }
   });
 
-  test('open() returns synchronously', () => {
+  test('open() returns void (synchronous)', async () => {
     if (!container) return;
 
-    const term = new Terminal();
-    const startTime = Date.now();
-
-    // open() should return immediately (not wait for WASM)
-    term.open(container);
+    const term = await createIsolatedTerminal();
+    const result = term.open(container);
 
-    const elapsed = Date.now() - startTime;
-    // Should return in under 50ms (WASM loading takes longer)
-    expect(elapsed).toBeLessThan(50);
+    expect(result).toBeUndefined();
 
     term.dispose();
   });
 
-  test('element is set immediately after open()', () => {
+  test('element is set after open', async () => {
     if (!container) return;
 
-    const term = new Terminal();
+    const term = await createIsolatedTerminal();
     term.open(container);
 
     expect(term.element).toBe(container);
@@ -2146,10 +1995,10 @@ describe('Synchronous open()', () => {
     term.dispose();
   });
 
-  test('cols and rows are available immediately after open()', () => {
+  test('cols and rows are available after open', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 100, rows: 50 });
+    const term = await createIsolatedTerminal({ cols: 100, rows: 50 });
     term.open(container);
 
     expect(term.cols).toBe(100);
@@ -2158,40 +2007,27 @@ describe('Synchronous open()', () => {
     term.dispose();
   });
 
-  test('resize queues and applies after ready', async () => {
+  test('wasmTerm is available after open', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24 });
+    const term = await createIsolatedTerminal();
     term.open(container);
 
-    // Wait for terminal to be ready
-    await new Promise((r) => term.onReady(r));
-
-    // Resize after ready should work
-    term.resize(120, 40);
-
-    expect(term.cols).toBe(120);
-    expect(term.rows).toBe(40);
+    expect(term.wasmTerm).toBeDefined();
 
     term.dispose();
   });
 
-  test('FitAddon can update cols/rows before ready', () => {
+  test('resize works after open', async () => {
     if (!container) return;
 
-    const term = new Terminal({ cols: 80, rows: 24 });
-
-    // Load FitAddon
-    const { FitAddon } = require('./addons/fit');
-    const fitAddon = new FitAddon();
-    term.loadAddon(fitAddon);
-
+    const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
     term.open(container);
 
-    // At this point, cols/rows are set from options
-    // FitAddon may update them synchronously via the resize path
-    expect(term.cols).toBeGreaterThan(0);
-    expect(term.rows).toBeGreaterThan(0);
+    term.resize(120, 40);
+
+    expect(term.cols).toBe(120);
+    expect(term.rows).toBe(40);
 
     term.dispose();
   });
diff --git a/lib/terminal.ts b/lib/terminal.ts
index fb9d1ade..d3bee144 100644
--- a/lib/terminal.ts
+++ b/lib/terminal.ts
@@ -5,8 +5,11 @@
  *
  * Usage:
  * ```typescript
- * const term = new Terminal({ cols: 80, rows: 24 });
- * term.open(document.getElementById('container')); // Synchronous - no await needed!
+ * import { init, Terminal } from 'ghostty-web';
+ *
+ * await init();
+ * const term = new Terminal();
+ * term.open(document.getElementById('container'));
  * term.write('Hello, World!\n');
  * term.onData(data => console.log('User typed:', data));
  * ```
@@ -14,7 +17,8 @@
 
 import { BufferNamespace } from './buffer';
 import { EventEmitter } from './event-emitter';
-import { Ghostty, type GhosttyCell, type GhosttyTerminal } from './ghostty';
+import type { Ghostty, GhosttyCell, GhosttyTerminal } from './ghostty';
+import { getGhostty } from './index';
 import { InputHandler } from './input-handler';
 import type {
   IBufferNamespace,
@@ -56,13 +60,7 @@ export class Terminal implements ITerminalCore {
   };
 
   // Options (public for xterm.js compatibility)
-  public readonly options!: Required<Omit<ITerminalOptions, 'wasmPath'>> & {
-    wasmPath?: string;
-  };
-
-  // WASM loading state (for synchronous open())
-  private wasmLoadPromise?: Promise<Ghostty>;
-  private pendingWrites: Array<{ data: string | Uint8Array; callback?: () => void }> = [];
+  public readonly options!: Required<ITerminalOptions>;
 
   // Components (created on open())
   private ghostty?: Ghostty;
@@ -88,8 +86,6 @@ export class Terminal implements ITerminalCore {
   private scrollEmitter = new EventEmitter<number>();
   private renderEmitter = new EventEmitter<{ start: number; end: number }>();
   private cursorMoveEmitter = new EventEmitter<void>();
-  private readyEmitter = new EventEmitter<void>();
-
   // Public event accessors (xterm.js compatibility)
   public readonly onData: IEvent<string> = this.dataEmitter.event;
   public readonly onResize: IEvent<{ cols: number; rows: number }> = this.resizeEmitter.event;
@@ -101,20 +97,8 @@ export class Terminal implements ITerminalCore {
   public readonly onRender: IEvent<{ start: number; end: number }> = this.renderEmitter.event;
   public readonly onCursorMove: IEvent<void> = this.cursorMoveEmitter.event;
 
-  // onReady is special - fires immediately if terminal is already ready
-  // This is critical for FitAddon which may subscribe before or after terminal is ready
-  public readonly onReady: IEvent<void> = (listener: () => void) => {
-    if (this.isReady) {
-      // Terminal already ready, fire immediately for late subscribers
-      listener();
-    }
-    // Also subscribe for future events
-    return this.readyEmitter.event(listener);
-  };
-
   // Lifecycle state
   private isOpen = false;
-  private isReady = false;
   private isDisposed = false;
   private animationFrameId?: number;
 
@@ -149,7 +133,10 @@ export class Terminal implements ITerminalCore {
   private readonly SCROLLBAR_FADE_DURATION_MS = 200; // 200ms fade animation
 
   constructor(options: ITerminalOptions = {}) {
-    // Create base options object with all defaults
+    // Use provided Ghostty instance (for test isolation) or get module-level instance
+    this.ghostty = options.ghostty ?? getGhostty();
+
+    // Create base options object with all defaults (excluding ghostty)
     const baseOptions = {
       cols: options.cols ?? 80,
       rows: options.rows ?? 24,
@@ -163,7 +150,6 @@ export class Terminal implements ITerminalCore {
       convertEol: options.convertEol ?? false,
       disableStdin: options.disableStdin ?? false,
       smoothScrollDuration: options.smoothScrollDuration ?? 100, // Default: 100ms smooth scroll
-      wasmPath: options.wasmPath, // Optional - Ghostty.load() handles defaults
     };
 
     // Wrap in Proxy to intercept runtime changes (xterm.js compatibility)
@@ -186,9 +172,6 @@ export class Terminal implements ITerminalCore {
 
     // Initialize buffer API
     this.buffer = new BufferNamespace(this);
-
-    // Start WASM loading immediately (makes open() synchronous)
-    this.wasmLoadPromise = Ghostty.load(this.options.wasmPath);
   }
 
   // ==========================================================================
@@ -243,11 +226,9 @@ export class Terminal implements ITerminalCore {
 
   /**
    * Open terminal in a parent element
-   * This initializes all components and starts rendering
    *
-   * Note: This method is synchronous for xterm.js compatibility.
-   * WASM loading happens in the constructor, and terminal setup happens
-   * asynchronously in the background. Use onReady event to know when ready.
+   * Initializes all components and starts rendering.
+   * Requires a pre-loaded Ghostty instance passed to the constructor.
    */
   open(parent: HTMLElement): void {
     if (this.isOpen) {
@@ -259,33 +240,15 @@ export class Terminal implements ITerminalCore {
 
     // Store parent element
     this.element = parent;
-
-    // Mark as open immediately (terminal will become ready when WASM loads)
     this.isOpen = true;
 
-    // Wait for WASM to load, then setup terminal
-    this.wasmLoadPromise!.then((ghostty) => {
-      this.ghostty = ghostty;
-      this.setupTerminal(parent);
-    }).catch((err) => {
-      console.error('Failed to load Ghostty WASM:', err);
-      this.isOpen = false;
-      throw new Error(`Failed to load Ghostty WASM: ${err}`);
-    });
-  }
-
-  /**
-   * Setup terminal once WASM is loaded
-   * This is called asynchronously after open() returns
-   */
-  private setupTerminal(parent: HTMLElement): void {
     try {
       // Make parent focusable if it isn't already
       if (!parent.hasAttribute('tabindex')) {
         parent.setAttribute('tabindex', '0');
       }
 
-      // Create WASM terminal with current dimensions (may have been updated by FitAddon before ready)
+      // Create WASM terminal with current dimensions
       this.wasmTerm = this.ghostty!.createTerminal(this.cols, this.rows);
 
       // Create canvas element
@@ -409,18 +372,9 @@ export class Terminal implements ITerminalCore {
 
       // Focus input (auto-focus so user can start typing immediately)
       this.focus();
-
-      // Mark as ready and fire event (must be after all components initialized)
-      this.isReady = true;
-      this.readyEmitter.fire();
-
-      // Process any writes that came in before WASM was ready
-      while (this.pendingWrites.length > 0) {
-        const pending = this.pendingWrites.shift()!;
-        this.writeInternal(pending.data, pending.callback);
-      }
     } catch (error) {
       // Clean up on error
+      this.isOpen = false;
       this.cleanupComponents();
       throw new Error(`Failed to open terminal: ${error}`);
     }
@@ -437,18 +391,6 @@ export class Terminal implements ITerminalCore {
       data = data.replace(/\n/g, '\r\n');
     }
 
-    // Queue writes if WASM not ready yet
-    if (!this.wasmTerm) {
-      this.pendingWrites.push({ data, callback });
-      return;
-    }
-
-    // Process any pending writes first (FIFO order)
-    while (this.pendingWrites.length > 0) {
-      const pending = this.pendingWrites.shift()!;
-      this.writeInternal(pending.data, pending.callback);
-    }
-
     this.writeInternal(data, callback);
   }
 
diff --git a/lib/test-helpers.ts b/lib/test-helpers.ts
new file mode 100644
index 00000000..2d89d6a3
--- /dev/null
+++ b/lib/test-helpers.ts
@@ -0,0 +1,37 @@
+/**
+ * Test Helpers for ghostty-web
+ *
+ * Provides utilities for test isolation and setup.
+ */
+
+import { Ghostty } from './ghostty';
+import type { ITerminalOptions } from './interfaces';
+import { Terminal } from './terminal';
+
+/**
+ * Creates a Terminal instance with an isolated Ghostty WASM instance.
+ * This ensures complete test isolation with no shared state between tests.
+ *
+ * @param options - Terminal options (cols, rows, etc.)
+ * @returns Promise resolving to Terminal instance
+ *
+ * @example
+ * ```typescript
+ * import { createIsolatedTerminal } from './test-helpers';
+ *
+ * describe('My Tests', () => {
+ *   test('my test', async () => {
+ *     const term = await createIsolatedTerminal({ cols: 80, rows: 24 });
+ *     term.open(container);
+ *     // ... test logic ...
+ *     term.dispose();
+ *   });
+ * });
+ * ```
+ */
+export async function createIsolatedTerminal(
+  options: Omit<ITerminalOptions, 'ghostty'> = {}
+): Promise<Terminal> {
+  const ghostty = await Ghostty.load();
+  return new Terminal({ ...options, ghostty });
+}
