diff --git a/e2e-tests/package.json b/e2e-tests/package.json
index d67a41ec..a9df3712 100644
--- a/e2e-tests/package.json
+++ b/e2e-tests/package.json
@@ -4,14 +4,20 @@
   "private": true,
   "description": "End-to-end tests for Apex Language Server Extension",
   "scripts": {
-    "test": "echo 'E2E tests temporarily disabled' && exit 0",
-    "test:debug": "echo 'E2E tests temporarily disabled' && exit 0",
-    "test:visual": "echo 'E2E tests temporarily disabled' && exit 0",
-    "server": "echo 'E2E server temporarily disabled' && exit 0"
+    "test": "playwright test",
+    "test:debug": "DEBUG_MODE=1 playwright test --debug",
+    "test:visual": "DEBUG_MODE=1 playwright test --ui",
+    "server": "node test-server.js",
+    "clean": "echo 'No artifacts to clean in e2e-tests'",
+    "clean:all": "npm run clean"
   },
   "devDependencies": {
     "@playwright/test": "^1.55.0",
     "@types/node": "^20.11.30",
     "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "http-proxy-middleware": "^3.0.5"
   }
 }
diff --git a/e2e-tests/playwright.config.ts b/e2e-tests/playwright.config.ts
index b407ae1c..57b253f5 100644
--- a/e2e-tests/playwright.config.ts
+++ b/e2e-tests/playwright.config.ts
@@ -62,11 +62,11 @@ export default defineConfig({
   ],
 
   webServer: {
-    command: 'npm run test:e2e:server',
+    command: 'node test-server.js',
     port: 3000,
     reuseExistingServer: !process.env.CI,
     timeout: 120_000,
-    cwd: process.cwd().endsWith('e2e-tests') ? '..' : '.',
+    cwd: process.cwd().endsWith('e2e-tests') ? '.' : './e2e-tests',
   },
 
   timeout: process.env.CI ? 120_000 : 60_000,
diff --git a/e2e-tests/test-server.js b/e2e-tests/test-server.js
index e6fdd5f6..5ffb69f5 100644
--- a/e2e-tests/test-server.js
+++ b/e2e-tests/test-server.js
@@ -14,7 +14,7 @@ async function startTestServer() {
   try {
     const extensionDevelopmentPath = path.resolve(
       __dirname,
-      '../packages/apex-lsp-vscode-extension',
+      '../packages/apex-lsp-vscode-extension/dist',
     );
     const workspacePath = process.env.CI
       ? path.join(
@@ -31,14 +31,17 @@ async function startTestServer() {
     }
 
     // Verify extension is built (check for critical files)
-    const distPath = path.join(extensionDevelopmentPath, 'dist');
-    const packageJsonPath = path.join(distPath, 'package.json');
-    const extensionJsPath = path.join(distPath, 'extension.js');
-    const extensionWebJsPath = path.join(distPath, 'extension.web.js');
+    // extensionDevelopmentPath now points to the dist directory
+    const packageJsonPath = path.join(extensionDevelopmentPath, 'package.json');
+    const extensionJsPath = path.join(extensionDevelopmentPath, 'extension.js');
+    const extensionWebJsPath = path.join(
+      extensionDevelopmentPath,
+      'extension.web.js',
+    );
 
-    if (!fs.existsSync(distPath)) {
+    if (!fs.existsSync(extensionDevelopmentPath)) {
       throw new Error(
-        `Extension dist directory not found: ${distPath}. Run 'npm run build' in the extension directory first.`,
+        `Extension dist directory not found: ${extensionDevelopmentPath}. Run 'npm run build' in the extension directory first.`,
       );
     }
 
@@ -90,9 +93,9 @@ async function startTestServer() {
 
     // Log extension files for debugging
     console.log('📋 Extension files:');
-    const distFiles = fs.readdirSync(distPath);
+    const distFiles = fs.readdirSync(extensionDevelopmentPath);
     distFiles.forEach((file) => {
-      const filePath = path.join(distPath, file);
+      const filePath = path.join(extensionDevelopmentPath, file);
       const stats = fs.statSync(filePath);
       console.log(
         `   ${file} (${stats.isDirectory() ? 'dir' : stats.size + ' bytes'})`,
diff --git a/e2e-tests/tests/apex-extension-core.spec.ts b/e2e-tests/tests/apex-extension-core.spec.ts
index 40037f89..fa6be60c 100644
--- a/e2e-tests/tests/apex-extension-core.spec.ts
+++ b/e2e-tests/tests/apex-extension-core.spec.ts
@@ -8,14 +8,14 @@
 import { test, expect } from '@playwright/test';
 
 import {
-  setupFullTestSession,
+  setupApexTestEnvironment,
   performStrictValidation,
-  detectLCSIntegration,
-  waitForLCSReady,
   testLSPFunctionality,
-  verifyApexFileContentLoaded,
   verifyVSCodeStability,
-  positionCursorInConstructor,
+  executeHoverTestScenarios,
+  detectOutlineSymbols,
+  TestResultReporter,
+  TestConfiguration,
 } from '../utils/test-helpers';
 
 import {
@@ -24,7 +24,11 @@ import {
   captureOutlineViewScreenshot,
 } from '../utils/outline-helpers';
 
-import { SELECTORS, EXPECTED_APEX_SYMBOLS } from '../utils/constants';
+import {
+  SELECTORS,
+  EXPECTED_APEX_SYMBOLS,
+  HOVER_TEST_SCENARIOS,
+} from '../utils/constants';
 
 /**
  * Comprehensive E2E tests for Apex Language Server Extension with LCS Integration.
@@ -60,31 +64,19 @@ test.describe('Apex Extension with LCS Integration', () => {
   test('should start VS Code, activate extension, and validate LCS integration', async ({
     page,
   }) => {
-    // Setup complete test session with monitoring
-    const { consoleErrors, networkErrors } = await setupFullTestSession(page);
-
-    // Verify that Apex file content is loaded in the editor
-    await verifyApexFileContentLoaded(page, 'ApexClassExample');
-
-    // Wait for LCS services to be ready
-    await waitForLCSReady(page);
+    // Setup complete Apex test environment with LCS detection
+    const { consoleErrors, networkErrors, lcsDetection } =
+      await setupApexTestEnvironment(page, {
+        includeLCSDetection: true,
+        expectedContent: TestConfiguration.EXPECTED_APEX_FILE,
+      });
 
-    // Detect and validate LCS integration
-    const lcsDetection = await detectLCSIntegration(page);
-    console.log(lcsDetection.summary);
+    // Report LCS detection results
+    TestResultReporter.reportLCSDetection(lcsDetection!);
 
     // Test basic LSP functionality
     const lspFunctionality = await testLSPFunctionality(page);
-    console.log('🔧 LSP Functionality Test Results:');
-    console.log(
-      `   - Editor Responsive: ${lspFunctionality.editorResponsive ? '✅' : '❌'}`,
-    );
-    console.log(
-      `   - Completion Tested: ${lspFunctionality.completionTested ? '✅' : '❌'}`,
-    );
-    console.log(
-      `   - Symbols Tested: ${lspFunctionality.symbolsTested ? '✅' : '❌'}`,
-    );
+    TestResultReporter.reportLSPFunctionality(lspFunctionality);
 
     // Verify extension in extensions list
     console.log('📋 Checking extension list...');
@@ -103,22 +95,22 @@ test.describe('Apex Extension with LCS Integration', () => {
 
     // Perform comprehensive validation
     const validation = performStrictValidation(consoleErrors, networkErrors);
-    console.log(validation.summary);
+    TestResultReporter.reportValidation(validation);
 
     // Assert success criteria with LCS validation
     expect(validation.consoleValidation.allErrorsAllowed).toBe(true);
     expect(validation.networkValidation.allErrorsAllowed).toBe(true);
-    expect(lcsDetection.lcsIntegrationActive).toBe(true);
-    expect(lcsDetection.hasErrorIndicators).toBe(false);
+    expect(lcsDetection!.lcsIntegrationActive).toBe(true);
+    expect(lcsDetection!.hasErrorIndicators).toBe(false);
     expect(lspFunctionality.editorResponsive).toBe(true);
 
-    // Bundle size validation - LCS should produce larger bundles (>5MB)
-    if (lcsDetection.bundleSize) {
-      const sizeInMB = lcsDetection.bundleSize / 1024 / 1024;
-      expect(sizeInMB).toBeGreaterThan(5);
-      console.log(
-        `✅ Bundle size confirms LCS integration: ${sizeInMB.toFixed(2)} MB`,
+    // Bundle size validation using configuration
+    if (lcsDetection!.bundleSize) {
+      const bundleValidation = TestConfiguration.validateBundleSize(
+        lcsDetection!.bundleSize,
       );
+      expect(bundleValidation.meetsLCSThreshold).toBe(true);
+      expect(bundleValidation.isValid).toBe(true);
     }
 
     console.log('🎉 Core functionality with LCS integration test PASSED');
@@ -141,19 +133,17 @@ test.describe('Apex Extension with LCS Integration', () => {
   test('should parse Apex symbols and populate outline view with LCS type parsing', async ({
     page,
   }) => {
-    // Setup complete test session
-    const { consoleErrors, networkErrors } = await setupFullTestSession(page);
+    // Setup complete Apex test environment with LCS detection
+    const { consoleErrors, networkErrors, lcsDetection } =
+      await setupApexTestEnvironment(page, {
+        includeLCSDetection: true,
+        expectedContent: TestConfiguration.EXPECTED_APEX_FILE,
+      });
 
     // Ensure explorer view is accessible
     const explorer = page.locator(SELECTORS.EXPLORER);
     await expect(explorer).toBeVisible({ timeout: 30_000 });
 
-    // Verify that Apex file content is loaded in the editor
-    await verifyApexFileContentLoaded(page, 'ApexClassExample');
-
-    // Wait for LCS services to be ready
-    await waitForLCSReady(page);
-
     // Find and activate outline view
     await findAndActivateOutlineView(page);
 
@@ -166,43 +156,18 @@ test.describe('Apex Extension with LCS Integration', () => {
     // Assert LCS type parsing capabilities
     expect(symbolValidation.classFound).toBe(true);
 
-    // Validate LCS type parsing capabilities (nested types)
+    // Validate LCS type parsing capabilities using optimized symbol detection
     console.log('🏗️ Validating LCS type parsing capabilities...');
-
     const expectedLCSSymbols = [
       'ApexClassExample', // Main class
       'Configuration', // Inner class
       'StatusType', // Inner enum
     ];
 
-    let lcsSymbolsFound = 0;
-    const foundLCSSymbols: string[] = [];
-
-    for (const symbol of expectedLCSSymbols) {
-      const symbolSelectors = [
-        `text=${symbol}`,
-        `.outline-tree .monaco-list-row:has-text("${symbol}")`,
-        `[aria-label*="${symbol}"]`,
-        `.monaco-tree .monaco-list-row:has-text("${symbol}")`,
-      ];
-
-      let symbolFound = false;
-      for (const selector of symbolSelectors) {
-        const elements = page.locator(selector);
-        const count = await elements.count();
-        if (count > 0) {
-          lcsSymbolsFound++;
-          foundLCSSymbols.push(symbol);
-          symbolFound = true;
-          console.log(`✅ Found LCS symbol: ${symbol}`);
-          break;
-        }
-      }
-
-      if (!symbolFound) {
-        console.log(`❌ LCS symbol not found: ${symbol}`);
-      }
-    }
+    const { foundSymbols, foundCount } = await detectOutlineSymbols(
+      page,
+      expectedLCSSymbols,
+    );
 
     // Count total outline items
     const outlineItems = page.locator(
@@ -210,13 +175,12 @@ test.describe('Apex Extension with LCS Integration', () => {
     );
     const totalItems = await outlineItems.count();
 
-    // Detect LCS integration status
-    const lcsDetection = await detectLCSIntegration(page);
-    console.log(lcsDetection.summary);
+    // Report LCS detection results
+    TestResultReporter.reportLCSDetection(lcsDetection!);
 
     // Perform validation
     const validation = performStrictValidation(consoleErrors, networkErrors);
-    console.log(validation.summary);
+    TestResultReporter.reportValidation(validation);
 
     // Capture screenshot for debugging
     await captureOutlineViewScreenshot(page, 'lcs-outline-parsing-test.png');
@@ -226,144 +190,69 @@ test.describe('Apex Extension with LCS Integration', () => {
     expect(validation.networkValidation.allErrorsAllowed).toBe(true);
     expect(symbolValidation.classFound).toBe(true); // Main class must be found
     expect(totalItems).toBeGreaterThan(0);
-    expect(lcsSymbolsFound).toBeGreaterThanOrEqual(2); // At least main class + 1 nested type
-    expect(lcsDetection.lcsIntegrationActive).toBe(true);
+    expect(foundCount).toBeGreaterThanOrEqual(
+      TestConfiguration.MIN_EXPECTED_SYMBOLS,
+    );
+    expect(lcsDetection!.lcsIntegrationActive).toBe(true);
 
     // Verify LCS type parsing capabilities
-    expect(foundLCSSymbols).toContain('ApexClassExample'); // Main class
-    expect(foundLCSSymbols.length).toBeGreaterThanOrEqual(2); // At least 2 types parsed
-
-    // Report comprehensive results
-    console.log('🎉 LCS Type Parsing and Outline View test COMPLETED');
-    console.log('   - File: ✅ ApexClassExample.cls opened and loaded');
-    console.log('   - Extension: ✅ Language features activated');
-    console.log('   - LCS Integration: ✅ Active and functional');
-    console.log('   - Outline: ✅ Outline view loaded and accessible');
-    console.log(
-      `     • Class: ${symbolValidation.classFound ? '✅' : '❌'} ${EXPECTED_APEX_SYMBOLS.className}`,
+    expect(foundSymbols).toContain('ApexClassExample'); // Main class
+    expect(foundSymbols.length).toBeGreaterThanOrEqual(
+      TestConfiguration.MIN_EXPECTED_SYMBOLS,
     );
-    console.log(
-      `     • Types parsed: ${lcsSymbolsFound}/${expectedLCSSymbols.length} (${foundLCSSymbols.join(', ')})`,
-    );
-    console.log(`   - Total outline elements: ${totalItems}`);
-    console.log(
-      '   ✨ This test validates LCS integration and comprehensive type parsing',
+
+    // Report comprehensive results using standardized reporter
+    TestResultReporter.reportSymbolValidation(
+      symbolValidation,
+      expectedLCSSymbols,
+      foundSymbols,
+      totalItems,
     );
   });
 
   /**
-   * Advanced LCS language services functionality test.
+   * Comprehensive hover functionality test with LCS integration.
    *
-   * This test validates that LCS language services are working correctly
-   * by testing a single, reliable completion scenario.
+   * This test validates that hover functionality works correctly for various
+   * Apex symbols including classes, methods, variables, and built-in types.
+   *
+   * Note: This test excludes standard Apex library classes (System, UserInfo, String methods)
+   * as the standard apex library is currently not working. The test focuses on user-defined
+   * classes and built-in types that should work with the current implementation.
    *
    * Verifies:
-   * - LCS completion services work (System.debug completion)
-   * - Document symbol functionality
-   * - Editor remains responsive during LCS operations
-   * - No fallback to stub implementation
-   * - Language service message flow works correctly
+   * - Hover functionality is active and responsive for user-defined symbols
+   * - Different symbol types provide appropriate hover information
+   * - Hover content includes type information and signatures
+   * - LCS integration provides rich hover data
    */
-  test('should demonstrate advanced LCS language services functionality', async ({
+  test('should provide comprehensive hover information for Apex symbols', async ({
     page,
   }) => {
-    // Setup complete test session
-    const { consoleErrors, networkErrors } = await setupFullTestSession(page);
-
-    // Wait for LCS services to be ready
-    await waitForLCSReady(page);
-
-    // Test core completion functionality - System.debug should always work in Apex
-    console.log('🔍 Testing System.debug completion...');
-    const editor = page.locator(SELECTORS.MONACO_EDITOR);
-    await editor.click();
-
-    // Position cursor and test System.debug completion
-    await positionCursorInConstructor(page);
-    await page.keyboard.type('System.');
-
-    // Trigger completion
-    await page.keyboard.press('ControlOrMeta+Space');
-
-    // Wait for completion widget to appear - fail if it doesn't
-    await page.waitForSelector(
-      '.suggest-widget.visible, .monaco-list[aria-label*="suggest"], [aria-label*="IntelliSense"]',
-      {
-        timeout: 5000,
-        state: 'visible',
-      },
-    );
+    // Setup complete Apex test environment (no LCS detection needed for hover test)
+    await setupApexTestEnvironment(page, {
+      includeLCSDetection: false,
+      expectedContent: TestConfiguration.EXPECTED_APEX_FILE,
+    });
 
-    const completionWidget = page.locator(
-      '.suggest-widget.visible, .monaco-list[aria-label*="suggest"], [aria-label*="IntelliSense"]',
+    console.log('🔍 Testing hover functionality for subset of Apex symbols...');
+    console.log(
+      '   Note: Standard Apex library (System, UserInfo, String methods) currently excluded',
     );
 
-    // Verify completion widget is visible
-    expect(completionWidget).toBeVisible();
-
-    // Verify completion items exist
-    const completionItems = page.locator('.monaco-list-row');
-    const itemCount = await completionItems.count();
-    expect(itemCount).toBeGreaterThan(0);
-
-    // Verify System.debug is available in completions
-    const systemDebugItem = page.locator('.monaco-list-row:has-text("debug")');
-    expect(systemDebugItem).toBeVisible();
-
-    console.log(`✅ System.debug completion working with ${itemCount} items`);
-
-    // Close completion and clean up
-    await page.keyboard.press('Escape');
-    await page.keyboard.press('Control+Z'); // Undo typing
-
-    // Test document symbols functionality
-    console.log('🔍 Testing document symbols...');
-    await page.keyboard.press('ControlOrMeta+Shift+O');
-
-    const symbolPicker = page.locator(
-      '.quick-input-widget, [id*="quickInput"]',
+    // Execute all hover scenarios with optimized batch processing
+    const hoverResults = await executeHoverTestScenarios(
+      page,
+      HOVER_TEST_SCENARIOS,
     );
-    await symbolPicker.waitFor({ state: 'visible', timeout: 3000 });
-    expect(symbolPicker).toBeVisible();
-
-    // Verify symbols are available
-    const symbolItems = page.locator('.quick-input-widget .monaco-list-row');
-    const symbolCount = await symbolItems.count();
-    expect(symbolCount).toBeGreaterThan(0);
 
-    console.log(`✅ Document symbols working with ${symbolCount} symbols`);
+    // Report results using standardized reporter
+    TestResultReporter.reportHoverResults(hoverResults);
 
-    // Close symbol picker
-    await page.keyboard.press('Escape');
+    // Assert all hover scenarios passed
+    expect(hoverResults.length).toBe(HOVER_TEST_SCENARIOS.length);
+    expect(hoverResults.every((result) => result.success)).toBe(true);
 
-    // Detect LCS integration
-    const lcsDetection = await detectLCSIntegration(page);
-    console.log(lcsDetection.summary);
-
-    // Perform validation
-    const validation = performStrictValidation(consoleErrors, networkErrors);
-    console.log(validation.summary);
-
-    // Verify system stability
-    await verifyVSCodeStability(page);
-
-    console.log('🔧 Advanced LCS Functionality Results:');
-    console.log('   - System.debug Completion: ✅ WORKING');
-    console.log('   - Document Symbols: ✅ WORKING');
-    console.log(
-      `   - LCS Integration: ${lcsDetection.lcsIntegrationActive ? '✅ ACTIVE' : '❌ INACTIVE'}`,
-    );
-
-    // Assert all functionality criteria - fail loudly if any component fails
-    expect(validation.consoleValidation.allErrorsAllowed).toBe(true);
-    expect(validation.networkValidation.allErrorsAllowed).toBe(true);
-    expect(lcsDetection.lcsIntegrationActive).toBe(true);
-    expect(lcsDetection.hasStubFallback).toBe(false); // Must not fall back to stub
-    expect(lcsDetection.hasErrorIndicators).toBe(false);
-
-    console.log('🎉 Advanced LCS Language Services test PASSED');
-    console.log(
-      '   ✨ This test validates core LCS language service functionality without fallbacks',
-    );
+    console.log('🎉 Hover Functionality test PASSED');
   });
 });
diff --git a/e2e-tests/utils/constants.ts b/e2e-tests/utils/constants.ts
index 73f9ed59..55a499a0 100644
--- a/e2e-tests/utils/constants.ts
+++ b/e2e-tests/utils/constants.ts
@@ -45,6 +45,8 @@ export const NON_CRITICAL_ERROR_PATTERNS: readonly ErrorFilterPattern[] = [
 
   // LSP and language server related non-critical errors
   'Request textDocument/diagnostic failed', // Known VS Code Web LSP issue Todo: W-19587882 for removal
+  'Request textDocument/completion failed', // Expected when standard library is not loaded
+  'Unhandled method textDocument/completion', // Expected when standard library is not loaded
 
   // VS Code lifecycle and shutdown related
   'Long running operations during shutdown',
@@ -52,6 +54,11 @@ export const NON_CRITICAL_ERROR_PATTERNS: readonly ErrorFilterPattern[] = [
 
   // Network and connectivity (often transient)
   'hostname could not be found',
+
+  // Grammar and syntax highlighting files (expected in web environment)
+  'apex.tmLanguage',
+  'grammars/apex.tmLanguage',
+  'Unable to load and parse grammar',
 ] as const;
 
 /**
@@ -63,6 +70,10 @@ export const NON_CRITICAL_NETWORK_PATTERNS: readonly ErrorFilterPattern[] = [
   // VS Code Web resource loading (404 errors are expected)
   'webPackagePaths.js',
   'workbench.web.main.nls.js',
+
+  // Grammar files (expected to be missing in web environment)
+  'apex.tmLanguage',
+  'grammars/apex.tmLanguage',
 ] as const;
 
 /**
@@ -326,3 +337,50 @@ export const EXPECTED_APEX_SYMBOLS: ExpectedApexSymbols = {
   ],
   totalSymbols: 3, // 1 main class + 1 inner class + 1 inner enum (Configuration + StatusType)
 };
+
+/**
+ * Hover test scenarios for different Apex symbols in the ApexClassExample.cls file.
+ * These scenarios test hover functionality for various symbol types.
+ */
+export const HOVER_TEST_SCENARIOS = [
+  {
+    description: 'Static variable hover',
+    searchText: 'private static final String DEFAULT_STATUS',
+  },
+  {
+    description: 'Instance variable hover',
+    searchText: 'private String instanceId',
+  },
+  {
+    description: 'List variable hover',
+    searchText: 'private List<Account> accounts',
+  },
+  {
+    description: 'Method name hover',
+    searchText: 'public static void sayHello',
+  },
+  {
+    description: 'Method with parameters hover',
+    searchText: 'public static Integer add',
+  },
+  {
+    description: 'Inner class hover',
+    searchText: 'public class Configuration',
+  },
+  {
+    description: 'Inner enum hover',
+    searchText: 'public enum StatusType',
+  },
+  {
+    description: 'Enum value hover',
+    searchText: 'ACTIVE, INACTIVE, PENDING, SUSPENDED',
+  },
+  {
+    description: 'Parameter hover',
+    searchText: 'List<Account> inputAccounts',
+  },
+  {
+    description: 'Local variable hover',
+    searchText: 'Map<Id, Account> accountMap',
+  },
+] as const;
diff --git a/e2e-tests/utils/error-handling.ts b/e2e-tests/utils/error-handling.ts
new file mode 100644
index 00000000..359e02c5
--- /dev/null
+++ b/e2e-tests/utils/error-handling.ts
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import { expect, type Page } from '@playwright/test';
+import type { ConsoleError, NetworkError } from './constants';
+import {
+  NON_CRITICAL_ERROR_PATTERNS,
+  NON_CRITICAL_NETWORK_PATTERNS,
+  SELECTORS,
+} from './constants';
+
+/**
+ * Configuration for error validation.
+ */
+export interface ErrorValidationConfig<T> {
+  readonly patterns: readonly string[];
+  readonly getErrorText: (error: T) => string;
+  readonly getErrorUrl?: (error: T) => string;
+  readonly includeWarnings?: boolean;
+}
+
+/**
+ * Result of error validation.
+ */
+export interface ErrorValidationResult<T> {
+  readonly allErrorsAllowed: boolean;
+  readonly nonAllowedErrors: T[];
+  readonly totalErrors: number;
+  readonly allowedErrors: number;
+}
+
+/**
+ * Options for waiting operations.
+ */
+export interface WaitOptions {
+  readonly timeout?: number;
+  readonly interval?: number;
+  readonly retries?: number;
+}
+
+/**
+ * Error handling options.
+ */
+export interface ErrorHandlingOptions {
+  readonly logError?: boolean;
+  readonly throwError?: boolean;
+  readonly defaultValue?: any;
+  readonly context?: string;
+}
+
+/**
+ * Generic error validation utility.
+ */
+export class ErrorValidator {
+  /**
+   * Validates errors against allowed patterns.
+   */
+  static validateErrors<T>(
+    errors: T[],
+    config: ErrorValidationConfig<T>,
+  ): ErrorValidationResult<T> {
+    const nonAllowedErrors: T[] = [];
+    let allowedErrors = 0;
+
+    errors.forEach((error) => {
+      const text = config.getErrorText(error).toLowerCase();
+      const url = config.getErrorUrl?.(error)?.toLowerCase() || '';
+
+      const isAllowed = config.patterns.some(
+        (pattern) =>
+          text.includes(pattern.toLowerCase()) ||
+          url.includes(pattern.toLowerCase()) ||
+          (config.includeWarnings && text.includes('warning')),
+      );
+
+      if (isAllowed) {
+        allowedErrors++;
+      } else {
+        nonAllowedErrors.push(error);
+      }
+    });
+
+    return {
+      allErrorsAllowed: nonAllowedErrors.length === 0,
+      nonAllowedErrors,
+      totalErrors: errors.length,
+      allowedErrors,
+    };
+  }
+
+  /**
+   * Filters errors to exclude non-critical patterns.
+   */
+  static filterCriticalErrors<T>(
+    errors: T[],
+    config: ErrorValidationConfig<T>,
+  ): T[] {
+    return errors.filter((error) => {
+      const text = config.getErrorText(error).toLowerCase();
+      const url = config.getErrorUrl?.(error)?.toLowerCase() || '';
+
+      return !config.patterns.some(
+        (pattern) =>
+          text.includes(pattern.toLowerCase()) ||
+          url.includes(pattern.toLowerCase()) ||
+          (config.includeWarnings && text.includes('warning')),
+      );
+    });
+  }
+}
+
+/**
+ * Standardized error handling utility.
+ */
+export class ErrorHandler {
+  /**
+   * Handles errors with consistent logging and behavior.
+   */
+  static handle<T>(
+    error: unknown,
+    options: ErrorHandlingOptions = {},
+  ): T | undefined {
+    const {
+      logError = true,
+      throwError = false,
+      defaultValue,
+      context = 'Operation',
+    } = options;
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    if (logError) {
+      console.log(`⚠️ ${context} failed: ${errorMessage}`);
+    }
+
+    if (throwError) {
+      throw error instanceof Error ? error : new Error(errorMessage);
+    }
+
+    return defaultValue;
+  }
+
+  /**
+   * Safely executes an async operation with error handling.
+   */
+  static async safeExecute<T>(
+    operation: () => Promise<T>,
+    options: ErrorHandlingOptions = {},
+  ): Promise<T | undefined> {
+    try {
+      return await operation();
+    } catch (error) {
+      return this.handle<T>(error, options);
+    }
+  }
+
+  /**
+   * Safely executes a sync operation with error handling.
+   */
+  static safeExecuteSync<T>(
+    operation: () => T,
+    options: ErrorHandlingOptions = {},
+  ): T | undefined {
+    try {
+      return operation();
+    } catch (error) {
+      return this.handle<T>(error, options);
+    }
+  }
+}
+
+/**
+ * Utility class for standardized waiting strategies.
+ */
+export class WaitingStrategies {
+  /**
+   * Waits for a condition to be true with configurable timeout and interval.
+   */
+  static async waitForCondition(
+    condition: () => Promise<boolean>,
+    options: WaitOptions = {},
+  ): Promise<void> {
+    const {
+      timeout = 10000,
+      interval = 100,
+      retries = Math.floor(timeout / interval),
+    } = options;
+
+    for (let i = 0; i < retries; i++) {
+      try {
+        if (await condition()) {
+          return;
+        }
+      } catch (_error) {
+        // Continue trying
+      }
+
+      if (i < retries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+      }
+    }
+
+    throw new Error(`Condition not met within ${timeout}ms`);
+  }
+
+  /**
+   * Waits for LSP server to be responsive by checking editor functionality.
+   */
+  static async waitForLSPResponsive(
+    page: Page,
+    options: WaitOptions = {},
+  ): Promise<void> {
+    const { timeout = 15000 } = options;
+
+    await this.waitForCondition(
+      async () => {
+        try {
+          // Check if editor is responsive to basic operations
+          const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
+          if (!(await monacoEditor.isVisible())) return false;
+
+          // Try to focus the editor as a responsiveness test
+          await monacoEditor.click({ timeout: 1000 });
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      { timeout },
+    );
+  }
+}
+
+/**
+ * Sets up console error monitoring for a page.
+ *
+ * @param page - Playwright page instance
+ * @returns Array to collect console errors
+ */
+export const setupConsoleMonitoring = (page: Page): ConsoleError[] => {
+  const consoleErrors: ConsoleError[] = [];
+
+  page.on('console', (msg) => {
+    if (msg.type() === 'error') {
+      consoleErrors.push({
+        text: msg.text(),
+        url: msg.location()?.url || '',
+      });
+    }
+  });
+
+  return consoleErrors;
+};
+
+/**
+ * Sets up network error monitoring for all failed requests.
+ *
+ * @param page - Playwright page instance
+ * @returns Array to collect network errors
+ */
+export const setupNetworkMonitoring = (page: Page): NetworkError[] => {
+  const networkErrors: NetworkError[] = [];
+
+  page.on('response', (response) => {
+    if (!response.ok()) {
+      networkErrors.push({
+        status: response.status(),
+        url: response.url(),
+        description: `HTTP ${response.status()} ${response.statusText()}`,
+      });
+    }
+  });
+
+  return networkErrors;
+};
+
+/**
+ * Filters console errors to exclude non-critical patterns.
+ *
+ * @param errors - Array of console errors to filter
+ * @returns Filtered array of critical errors only
+ */
+export const filterCriticalErrors = (errors: ConsoleError[]): ConsoleError[] =>
+  ErrorValidator.filterCriticalErrors(errors, {
+    patterns: NON_CRITICAL_ERROR_PATTERNS,
+    getErrorText: (error) => error.text,
+    getErrorUrl: (error) => error.url || '',
+    includeWarnings: true,
+  });
+
+/**
+ * Validates that all console errors are in the allowList.
+ * Returns detailed information about any errors that are NOT allowed.
+ *
+ * @param errors - Array of console errors to validate
+ * @returns Object with validation results and details about non-allowed errors
+ */
+export const validateAllErrorsInAllowList = (
+  errors: ConsoleError[],
+): ErrorValidationResult<ConsoleError> =>
+  ErrorValidator.validateErrors(errors, {
+    patterns: NON_CRITICAL_ERROR_PATTERNS,
+    getErrorText: (error) => error.text,
+    getErrorUrl: (error) => error.url || '',
+    includeWarnings: true,
+  });
+
+/**
+ * Validates that all network errors are in the allowList.
+ * Returns detailed information about any errors that are NOT allowed.
+ *
+ * @param errors - Array of network errors to validate
+ * @returns Object with validation results and details about non-allowed errors
+ */
+export const validateAllNetworkErrorsInAllowList = (
+  errors: NetworkError[],
+): ErrorValidationResult<NetworkError> =>
+  ErrorValidator.validateErrors(errors, {
+    patterns: NON_CRITICAL_NETWORK_PATTERNS,
+    getErrorText: (error) => error.description,
+    getErrorUrl: (error) => error.url,
+    includeWarnings: false,
+  });
diff --git a/e2e-tests/utils/lsp-testing.ts b/e2e-tests/utils/lsp-testing.ts
new file mode 100644
index 00000000..3cfeb1a7
--- /dev/null
+++ b/e2e-tests/utils/lsp-testing.ts
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import { expect, type Page } from '@playwright/test';
+import { SELECTORS } from './constants';
+import { findAndActivateOutlineView } from './outline-helpers';
+import { ErrorHandler, WaitingStrategies } from './error-handling';
+import type { WaitOptions } from './error-handling';
+
+/**
+ * Hover test scenario definition.
+ */
+export interface HoverTestScenario {
+  /** Description of what we're testing */
+  readonly description: string;
+  /** Text to search for to position cursor */
+  readonly searchText: string;
+  /** Whether to move cursor to end of found text */
+  readonly moveToEnd?: boolean;
+}
+
+/**
+ * Hover test result.
+ */
+export interface HoverTestResult {
+  readonly success: boolean;
+}
+
+/**
+ * LSP functionality test result.
+ */
+export interface LSPFunctionalityResult {
+  readonly completionTested: boolean;
+  readonly symbolsTested: boolean;
+  readonly editorResponsive: boolean;
+}
+
+/**
+ * Symbol detection result.
+ */
+interface SymbolDetectionResult {
+  readonly found: boolean;
+  readonly symbolName: string;
+  readonly foundSymbols: string[];
+}
+
+/**
+ * Symbol detection utilities for test optimization.
+ */
+class SymbolDetectionUtils {
+  /**
+   * Detects multiple symbols efficiently using batch selectors.
+   */
+  static async detectSymbols(
+    page: Page,
+    symbolNames: string[],
+  ): Promise<SymbolDetectionResult[]> {
+    const results: SymbolDetectionResult[] = [];
+
+    for (const symbolName of symbolNames) {
+      const symbolSelectors = [
+        `text=${symbolName}`,
+        `.outline-tree .monaco-list-row:has-text("${symbolName}")`,
+        `[aria-label*="${symbolName}"]`,
+        `.monaco-tree .monaco-list-row:has-text("${symbolName}")`,
+      ];
+
+      let found = false;
+      for (const selector of symbolSelectors) {
+        const elements = page.locator(selector);
+        const count = await elements.count();
+        if (count > 0) {
+          found = true;
+          console.log(`✅ Found LCS symbol: ${symbolName}`);
+          break;
+        }
+      }
+
+      if (!found) {
+        console.log(`❌ LCS symbol not found: ${symbolName}`);
+      }
+
+      results.push({
+        found,
+        symbolName,
+        foundSymbols: found ? [symbolName] : [],
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Aggregates symbol detection results.
+   */
+  static aggregateResults(results: SymbolDetectionResult[]): {
+    foundSymbols: string[];
+    foundCount: number;
+  } {
+    const foundSymbols = results
+      .filter((r) => r.found)
+      .map((r) => r.symbolName);
+
+    return {
+      foundSymbols,
+      foundCount: foundSymbols.length,
+    };
+  }
+}
+
+/**
+ * Batch hover test execution utility.
+ */
+class HoverTestUtils {
+  /**
+   * Executes multiple hover scenarios efficiently.
+   */
+  static async executeHoverScenarios(
+    page: Page,
+    scenarios: readonly HoverTestScenario[],
+  ): Promise<Array<{ scenario: HoverTestScenario; success: boolean }>> {
+    const results: Array<{
+      scenario: HoverTestScenario;
+      success: boolean;
+    }> = [];
+
+    // Wait for LSP server to be ready once for all scenarios
+    await WaitingStrategies.waitForLSPResponsive(page, { timeout: 3000 });
+
+    for (const scenario of scenarios) {
+      const result = await testHoverScenario(page, scenario);
+      results.push({
+        scenario,
+        success: result.success,
+      });
+    }
+
+    return results;
+  }
+}
+
+/**
+ * Waits for LCS services to be ready by checking for completion functionality.
+ * Replaces unreliable setTimeout calls with deterministic waiting.
+ *
+ * @param page - Playwright page instance
+ * @param options - Wait options
+ */
+export const waitForLCSReady = async (
+  page: Page,
+  options: WaitOptions = {},
+): Promise<void> => {
+  await ErrorHandler.safeExecute(
+    () => WaitingStrategies.waitForLSPResponsive(page, options),
+    {
+      context: 'LCS readiness check',
+      logError: false, // Use custom message
+      throwError: false,
+    },
+  );
+
+  // Always log completion for informational purposes
+  console.log('ℹ️ LCS readiness check completed');
+};
+
+/**
+ * Tests LSP language services functionality (completion, symbols, etc.).
+ * Consolidates LSP functionality testing from multiple files.
+ *
+ * @param page - Playwright page instance
+ * @returns Object indicating which LSP features are working
+ */
+export const testLSPFunctionality = async (
+  page: Page,
+): Promise<LSPFunctionalityResult> => {
+  const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
+  let completionTested = false;
+  let symbolsTested = false;
+  let editorResponsive = false;
+
+  try {
+    // Test editor responsiveness
+    await monacoEditor.click();
+    editorResponsive = await monacoEditor.isVisible();
+
+    // Test document symbols
+    const tryOpenSymbolPicker = async (): Promise<boolean> => {
+      const symbolPicker = page.locator(
+        '.quick-input-widget, [id*="quickInput"]',
+      );
+
+      // Try macOS chord first, then Windows/Linux
+      await page.keyboard.press('Meta+Shift+O');
+      await symbolPicker
+        .waitFor({ state: 'visible', timeout: 600 })
+        .catch(() => {});
+      if (await symbolPicker.isVisible().catch(() => false)) {
+        // Consider success only if list has items
+        const itemCount = await page
+          .locator('.quick-input-widget .monaco-list-row')
+          .count()
+          .catch(() => 0);
+        if (itemCount > 0) return true;
+      }
+
+      await page.keyboard.press('Control+Shift+O');
+      await symbolPicker
+        .waitFor({ state: 'visible', timeout: 600 })
+        .catch(() => {});
+      if (await symbolPicker.isVisible().catch(() => false)) {
+        const itemCount = await page
+          .locator('.quick-input-widget .monaco-list-row')
+          .count()
+          .catch(() => 0);
+        if (itemCount > 0) return true;
+      }
+
+      // Fallback: Command Palette → '@' (Go to Symbol in Editor)
+      await page.keyboard.press('F1');
+      const quickInput = page.locator('.quick-input-widget');
+      await quickInput
+        .waitFor({ state: 'visible', timeout: 1000 })
+        .catch(() => {});
+      await page.keyboard.type('@');
+      await page.keyboard.press('Enter');
+      await symbolPicker
+        .waitFor({ state: 'visible', timeout: 1200 })
+        .catch(() => {});
+      if (await symbolPicker.isVisible().catch(() => false)) {
+        const itemCount = await page
+          .locator('.quick-input-widget .monaco-list-row')
+          .count()
+          .catch(() => 0);
+        if (itemCount > 0) return true;
+      }
+      return false;
+    };
+
+    symbolsTested = await tryOpenSymbolPicker();
+    if (symbolsTested) {
+      await page.keyboard.press('Escape'); // Close symbol picker
+    }
+
+    // If picker approach failed, open Outline and accept outline as proof of symbol services
+    if (!symbolsTested) {
+      try {
+        await findAndActivateOutlineView(page);
+      } catch (_e) {
+        // ignore activation failure; we'll still try to detect rows
+      }
+      const outlineRows = page.locator(
+        '.outline-tree .monaco-list-row, .monaco-tree .monaco-list-row',
+      );
+      await outlineRows
+        .first()
+        .waitFor({ state: 'visible', timeout: 5000 })
+        .catch(() => {});
+      const outlineCount = await outlineRows.count().catch(() => 0);
+      symbolsTested = outlineCount > 0;
+
+      // If still no symbols, try alternative detection methods
+      if (!symbolsTested) {
+        // Check if document symbols API is available via VS Code command
+        try {
+          await page.keyboard.press('F1');
+          await page.waitForSelector('.quick-input-widget', { timeout: 2000 });
+          await page.keyboard.type('Go to Symbol in Editor');
+          await page.keyboard.press('Enter');
+          const symbolWidget = page.locator('.quick-input-widget');
+          await symbolWidget
+            .waitFor({ state: 'visible', timeout: 3000 })
+            .catch(() => {});
+          const symbolItems = await page
+            .locator('.quick-input-widget .monaco-list-row')
+            .count()
+            .catch(() => 0);
+          symbolsTested = symbolItems > 0;
+          await page.keyboard.press('Escape'); // Close the widget
+        } catch (_error) {
+          // Ignore symbol detection errors
+        }
+      }
+    }
+  } catch (_error) {
+    // LSP functionality testing is informational
+  }
+
+  return { completionTested, symbolsTested, editorResponsive };
+};
+
+/**
+ * Positions the cursor on a specific word in the editor by searching for it.
+ *
+ * @param page - Playwright page instance
+ * @param searchText - Text to search for to position cursor
+ * @param moveToEnd - Whether to move cursor to end of the found text (default: false)
+ */
+export const positionCursorOnWord = async (
+  page: Page,
+  searchText: string,
+  moveToEnd = false,
+): Promise<void> => {
+  await ErrorHandler.safeExecute(
+    async () => {
+      // Use Ctrl+F to find the text
+      await page.keyboard.press('Control+F');
+      // Wait for find input to appear
+      await page
+        .waitForSelector('input[aria-label="Find"], .find-widget', {
+          timeout: 1500,
+        })
+        .catch(() => {});
+
+      // Search for the text
+      await page.keyboard.type(searchText);
+      await page.keyboard.press('Enter'); // Search
+      await page.keyboard.press('Escape'); // Close search dialog
+
+      // Move to end of word if requested
+      if (moveToEnd) {
+        await page.keyboard.press('End');
+      }
+    },
+    {
+      context: `Position cursor on "${searchText}"`,
+      logError: true,
+      throwError: false,
+    },
+  );
+};
+
+/**
+ * Triggers a hover at the current cursor position and waits for hover widget to appear.
+ *
+ * @param page - Playwright page instance
+ * @param timeout - Timeout in milliseconds to wait for hover (default: 3000)
+ * @returns Whether hover widget appeared
+ */
+export const triggerHover = async (
+  page: Page,
+  timeout = 1500,
+): Promise<boolean> => {
+  try {
+    await page.keyboard.press('Control+K+I'); // VS Code hover shortcut
+    // Wait for hover widget to appear with specific selector
+    await expect(page.locator('.monaco-editor .hover-row')).toBeVisible({
+      timeout: 1500,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Tests hover functionality for a specific scenario.
+ *
+ * @param page - Playwright page instance
+ * @param scenario - Hover test scenario
+ * @returns Test result with details
+ */
+export const testHoverScenario = async (
+  page: Page,
+  scenario: HoverTestScenario,
+): Promise<HoverTestResult> => {
+  try {
+    console.log(`🔍 Testing hover: ${scenario.description}`);
+    // Wait for LSP server to be ready for hover requests
+    await WaitingStrategies.waitForLSPResponsive(page, { timeout: 3000 });
+
+    // Position cursor on the target text
+    await positionCursorOnWord(page, scenario.searchText, scenario.moveToEnd);
+
+    // Trigger hover with reduced timeout
+    const hoverAppeared = await triggerHover(page, 1500);
+
+    if (!hoverAppeared) {
+      console.log(`❌ No hover appeared for: ${scenario.description}`);
+      return {
+        success: false,
+      };
+    }
+
+    // Move cursor away or press Escape to dismiss hover
+    await page.keyboard.press('Escape');
+    return {
+      success: true,
+    };
+  } catch {
+    return {
+      success: false,
+    };
+  }
+};
+
+/**
+ * Executes multiple hover test scenarios with optimized performance.
+ *
+ * @param page - Playwright page instance
+ * @param scenarios - Array of hover test scenarios
+ * @returns Array of test results
+ */
+export const executeHoverTestScenarios = async (
+  page: Page,
+  scenarios: readonly HoverTestScenario[],
+): Promise<Array<{ scenario: HoverTestScenario; success: boolean }>> =>
+  HoverTestUtils.executeHoverScenarios(page, scenarios);
+
+/**
+ * Detects multiple symbols in the outline view efficiently.
+ *
+ * @param page - Playwright page instance
+ * @param symbolNames - Array of symbol names to detect
+ * @returns Symbol detection results
+ */
+export const detectOutlineSymbols = async (
+  page: Page,
+  symbolNames: string[],
+): Promise<{ foundSymbols: string[]; foundCount: number }> => {
+  const results = await SymbolDetectionUtils.detectSymbols(page, symbolNames);
+  return SymbolDetectionUtils.aggregateResults(results);
+};
diff --git a/e2e-tests/utils/outline-helpers.ts b/e2e-tests/utils/outline-helpers.ts
index 0337c5cf..df225468 100644
--- a/e2e-tests/utils/outline-helpers.ts
+++ b/e2e-tests/utils/outline-helpers.ts
@@ -37,7 +37,7 @@ export const findAndActivateOutlineView = async (page: Page): Promise<void> => {
       if (selector === 'text=OUTLINE') {
         await outlineElement.first().click();
         // Wait for outline tree to become visible after clicking
-        await page.waitForSelector('.outline-tree', { timeout: 4000 });
+        await page.waitForSelector('.outline-tree', { timeout: 10000 });
       }
       break;
     }
@@ -90,7 +90,7 @@ const activateOutlineViaCommandPalette = async (page: Page): Promise<void> => {
       await outlineCommand.click();
       // Wait for outline tree to appear after command execution
       await page.waitForSelector('.outline-tree, [id*="outline"]', {
-        timeout: 5000,
+        timeout: 10000,
       });
     } else {
       // Close command palette
@@ -237,7 +237,7 @@ export const validateApexSymbolsInOutline = async (
 }> => {
   // Wait for LSP to populate symbols by checking for any outline content
   await page.waitForSelector('.outline-tree .monaco-list-row', {
-    timeout: 5_000, // Outline generation timeout
+    timeout: 10_000, // Outline generation timeout
   });
 
   // Ensure outline tree is fully expanded and all symbols are visible
diff --git a/e2e-tests/utils/test-helpers.ts b/e2e-tests/utils/test-helpers.ts
index fd016299..e8cc4401 100644
--- a/e2e-tests/utils/test-helpers.ts
+++ b/e2e-tests/utils/test-helpers.ts
@@ -6,824 +6,101 @@
  * repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 
-import type { Page } from '@playwright/test';
-import type { ConsoleError, NetworkError } from './constants';
-import {
-  NON_CRITICAL_ERROR_PATTERNS,
-  NON_CRITICAL_NETWORK_PATTERNS,
-  SELECTORS,
-  APEX_CLASS_EXAMPLE_CONTENT,
-} from './constants';
-import { setupTestWorkspace } from './setup';
-
-/**
- * Early worker detection store keyed by Playwright Page.
- */
-interface WorkerDetectionState {
-  workerDetected: boolean;
-  bundleSize?: number;
-}
-
-const workerDetectionStore: WeakMap<Page, WorkerDetectionState> = new WeakMap();
-
-/**
- * Install an early response hook to capture worker bundle fetch before navigation.
- */
-export const setupWorkerResponseHook = (page: Page): void => {
-  const initial: WorkerDetectionState = { workerDetected: false };
-  workerDetectionStore.set(page, initial);
-
-  const isWorkerUrl = (url: string): boolean =>
-    url.includes('worker.js') && url.includes('devextensions');
-
-  page.on('response', async (response) => {
-    const url = response.url();
-    if (!isWorkerUrl(url)) return;
-    try {
-      const buffer = await response.body();
-      const state = workerDetectionStore.get(page) ?? { workerDetected: false };
-      state.workerDetected = true;
-      state.bundleSize = buffer.length;
-      workerDetectionStore.set(page, state);
-    } catch (_error) {
-      // Ignore size measurement errors
-      const state = workerDetectionStore.get(page) ?? { workerDetected: false };
-      state.workerDetected = true;
-      workerDetectionStore.set(page, state);
-    }
-  });
-};
-
-/**
- * Filters console errors to exclude non-critical patterns.
- *
- * @param errors - Array of console errors to filter
- * @returns Filtered array of critical errors only
- */
-export const filterCriticalErrors = (errors: ConsoleError[]): ConsoleError[] =>
-  errors.filter((error) => {
-    const text = error.text.toLowerCase();
-    const url = (error.url ?? '').toLowerCase();
-
-    return !NON_CRITICAL_ERROR_PATTERNS.some(
-      (pattern) =>
-        text.includes(pattern.toLowerCase()) ||
-        url.includes(pattern.toLowerCase()) ||
-        text.includes('warning'),
-    );
-  });
-
-/**
- * Validates that all console errors are in the allowList.
- * Returns detailed information about any errors that are NOT allowed.
- *
- * @param errors - Array of console errors to validate
- * @returns Object with validation results and details about non-allowed errors
- */
-export const validateAllErrorsInAllowList = (
-  errors: ConsoleError[],
-): {
-  allErrorsAllowed: boolean;
-  nonAllowedErrors: ConsoleError[];
-  totalErrors: number;
-  allowedErrors: number;
-} => {
-  const nonAllowedErrors: ConsoleError[] = [];
-  let allowedErrors = 0;
-
-  errors.forEach((error) => {
-    const text = error.text.toLowerCase();
-    const url = (error.url ?? '').toLowerCase();
-
-    const isAllowed = NON_CRITICAL_ERROR_PATTERNS.some(
-      (pattern) =>
-        text.includes(pattern.toLowerCase()) ||
-        url.includes(pattern.toLowerCase()) ||
-        text.includes('warning'),
-    );
-
-    if (isAllowed) {
-      allowedErrors++;
-    } else {
-      nonAllowedErrors.push(error);
-    }
-  });
-
-  return {
-    allErrorsAllowed: nonAllowedErrors.length === 0,
-    nonAllowedErrors,
-    totalErrors: errors.length,
-    allowedErrors,
-  };
-};
-
-/**
- * Validates that all network errors are in the allowList.
- * Returns detailed information about any errors that are NOT allowed.
- *
- * @param errors - Array of network errors to validate
- * @returns Object with validation results and details about non-allowed errors
- */
-export const validateAllNetworkErrorsInAllowList = (
-  errors: NetworkError[],
-): {
-  allErrorsAllowed: boolean;
-  nonAllowedErrors: NetworkError[];
-  totalErrors: number;
-  allowedErrors: number;
-} => {
-  const nonAllowedErrors: NetworkError[] = [];
-  let allowedErrors = 0;
-
-  errors.forEach((error) => {
-    const url = error.url.toLowerCase();
-    const description = error.description.toLowerCase();
-
-    const isAllowed = NON_CRITICAL_NETWORK_PATTERNS.some(
-      (pattern) =>
-        url.includes(pattern.toLowerCase()) ||
-        description.includes(pattern.toLowerCase()),
-    );
-
-    if (isAllowed) {
-      allowedErrors++;
-    } else {
-      nonAllowedErrors.push(error);
-    }
-  });
-
-  return {
-    allErrorsAllowed: nonAllowedErrors.length === 0,
-    nonAllowedErrors,
-    totalErrors: errors.length,
-    allowedErrors,
-  };
-};
-
-/**
- * Sets up console error monitoring for a page.
- *
- * @param page - Playwright page instance
- * @returns Array to collect console errors
- */
-export const setupConsoleMonitoring = (page: Page): ConsoleError[] => {
-  const consoleErrors: ConsoleError[] = [];
-
-  page.on('console', (msg) => {
-    if (msg.type() === 'error') {
-      consoleErrors.push({
-        text: msg.text(),
-        url: msg.location()?.url || '',
-      });
-    }
-  });
-
-  return consoleErrors;
-};
-
-/**
- * Sets up network error monitoring for all failed requests.
- *
- * @param page - Playwright page instance
- * @returns Array to collect network errors
- */
-export const setupNetworkMonitoring = (page: Page): NetworkError[] => {
-  const networkErrors: NetworkError[] = [];
-
-  page.on('response', (response) => {
-    if (!response.ok()) {
-      networkErrors.push({
-        status: response.status(),
-        url: response.url(),
-        description: `HTTP ${response.status()} ${response.statusText()}`,
-      });
-    }
-  });
-
-  return networkErrors;
-};
-
-/**
- * Starts VS Code Web and waits for it to load.
- *
- * @param page - Playwright page instance
- */
-export const startVSCodeWeb = async (page: Page): Promise<void> => {
-  await page.goto('/', { waitUntil: 'networkidle' });
-
-  // Wait for the page to be fully loaded
-  await page.waitForLoadState('domcontentloaded');
-
-  // Wait for VS Code workbench to be fully loaded and interactive
-  await page.waitForSelector(SELECTORS.STATUSBAR, {
-    timeout: 60_000, // VS Code startup timeout
-  });
-
-  // Verify VS Code workbench loaded
-  await page.waitForSelector(SELECTORS.WORKBENCH, {
-    timeout: 30_000, // Selector wait timeout
-  });
-  const workbench = page.locator(SELECTORS.WORKBENCH);
-  await workbench.waitFor({ state: 'visible' });
-
-  // Ensure the workbench is fully interactive
-  await page.waitForLoadState('networkidle');
-};
-
-/**
- * Verifies workspace files are loaded.
- *
- * @param page - Playwright page instance
- * @returns Number of Apex files found
- */
-export const verifyWorkspaceFiles = async (page: Page): Promise<number> => {
-  const explorer = page.locator(SELECTORS.EXPLORER);
-  await explorer.waitFor({ state: 'visible', timeout: 30_000 });
-
-  // Wait for the file system to stabilize in CI environments
-  if (process.env.CI) {
-    // Wait for explorer content to be fully loaded instead of using timeout
-    await page
-      .waitForFunction(
-        () => {
-          const explorer = document.querySelector(
-            '[id="workbench.view.explorer"]',
-          );
-          return explorer && explorer.children.length > 0;
-        },
-        { timeout: 5000 },
-      )
-      .catch(() => {
-        // If the function-based wait fails, use a short fallback
-      });
-  }
-
-  // Check if our test files are visible (Apex files)
-  const apexFiles = page.locator(SELECTORS.APEX_FILE_ICON);
-  const fileCount = await apexFiles.count();
-
-  return fileCount;
-};
-
-/**
- * Opens an Apex file to activate the extension.
- *
- * @param page - Playwright page instance
- */
-export const activateExtension = async (page: Page): Promise<void> => {
-  const clsFile = page.locator(SELECTORS.CLS_FILE_ICON).first();
-
-  await clsFile.waitFor({
-    state: 'visible',
-    timeout: 15_000,
-  });
-
-  if (await clsFile.isVisible()) {
-    // Hover to show file selection in debug mode
-    if (process.env.DEBUG_MODE) {
-      await clsFile.hover();
-      await page
-        .waitForSelector(SELECTORS.CLS_FILE_ICON + ':hover', { timeout: 1000 })
-        .catch(() => {
-          // Ignore hover selector timeout - it's just for debug visibility
-        });
-    }
-
-    await clsFile.click();
-  } else {
-    throw new Error('No .cls file found to activate extension');
-  }
-
-  // Wait for editor to load
-  await page.waitForSelector(SELECTORS.EDITOR_PART, { timeout: 15_000 });
-  const editorPart = page.locator(SELECTORS.EDITOR_PART);
-  await editorPart.waitFor({ state: 'visible' });
-
-  // Verify Monaco editor is present
-  const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
-  await monacoEditor.waitFor({ state: 'visible', timeout: 30_000 });
-
-  // Verify that file content is actually loaded in the editor
-  const editorText = page.locator('.monaco-editor .view-lines');
-  await editorText.waitFor({ state: 'visible', timeout: 5_000 });
-
-  // Check if the editor contains some text content
-  const hasContent = await editorText.locator('.view-line').first().isVisible();
-  if (!hasContent) {
-    throw new Error(
-      'Extension activated but file content may not be loaded yet',
-    );
-  }
-};
-
-/**
- * Waits for LSP server to initialize.
- *
- * @param page - Playwright page instance
- */
-export const waitForLSPInitialization = async (page: Page): Promise<void> => {
-  // Wait for Monaco editor to be ready and responsive
-  await page.waitForSelector(
-    SELECTORS.MONACO_EDITOR + ' .monaco-editor-background',
-    {
-      timeout: 30_000, // LSP initialization timeout
-    },
-  );
-
-  // Wait for any language server activity by checking for syntax highlighting or symbols
-  await page.evaluate(
-    async () =>
-      new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          const editor = document.querySelector('.monaco-editor .view-lines');
-          if (editor && editor.children.length > 0) {
-            clearInterval(checkInterval);
-            resolve(true);
-          }
-        }, 100);
-
-        // Timeout after 8 seconds
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          resolve(true);
-        }, 8000);
-      }),
-  );
-};
-
-/**
- * Verifies VS Code stability by checking core UI elements.
- *
- * @param page - Playwright page instance
- */
-export const verifyVSCodeStability = async (page: Page): Promise<void> => {
-  const sidebar = page.locator(SELECTORS.SIDEBAR);
-  await sidebar.waitFor({ state: 'visible' });
-
-  const statusbar = page.locator(SELECTORS.STATUSBAR);
-  await statusbar.waitFor({ state: 'visible' });
-};
-
-/**
- * Verifies that Apex code content is loaded and visible in the editor.
- * Throws an error if content is not loaded or doesn't match expectations.
- *
- * @param page - Playwright page instance
- * @param expectedContent - Optional specific content to look for
- * @throws Error if content is not visible or doesn't match expectations
- */
-export const verifyApexFileContentLoaded = async (
-  page: Page,
-  expectedContent?: string,
-): Promise<void> => {
-  try {
-    // Wait for editor content to load
-    const editorContent = page.locator('.monaco-editor .view-lines .view-line');
-    await editorContent.first().waitFor({ state: 'visible', timeout: 5_000 });
-
-    // Get the visible text content
-    const firstLineText = await editorContent.first().textContent();
-    const hasApexKeywords =
-      firstLineText &&
-      (firstLineText.includes('public') ||
-        firstLineText.includes('class') ||
-        firstLineText.includes('private') ||
-        firstLineText.includes('static'));
-
-    if (expectedContent) {
-      const allText = await editorContent.allTextContents();
-      const fullText = allText.join(' ');
-      const hasExpectedContent = fullText.includes(expectedContent);
-
-      if (hasExpectedContent) {
-        return;
-      } else {
-        throw new Error(
-          `Expected content "${expectedContent}" not found in editor`,
-        );
-      }
-    }
-
-    if (hasApexKeywords) {
-      return;
-    } else {
-      throw new Error('Editor content does not contain recognizable Apex code');
-    }
-  } catch (error) {
-    if (
-      error instanceof Error &&
-      (error.message.includes('Expected content') ||
-        error.message.includes('Editor content does not contain'))
-    ) {
-      throw error; // Re-throw our custom errors
-    }
-    throw new Error(`Could not verify editor content: ${error}`);
-  }
-};
-
-/**
- * Test sample file type definition.
- */
-export interface SampleFile {
-  readonly filename: string;
-  readonly content: string;
-}
-
-/**
- * Creates a sample file object for testing.
- *
- * @param filename - The file name with extension
- * @param content - The file content
- * @returns Sample file object for test workspace
- */
-const createSampleFile = (filename: string, content: string): SampleFile => ({
-  filename,
-  content,
-});
-
-/**
- * Creates the comprehensive Apex class example file.
- *
- * @returns Sample file with comprehensive Apex class content
- */
-const createApexClassExampleFile = (): SampleFile =>
-  createSampleFile('ApexClassExample.cls', APEX_CLASS_EXAMPLE_CONTENT);
-
-/**
- * All sample files for workspace creation.
- */
-export const ALL_SAMPLE_FILES = [createApexClassExampleFile()] as const;
-
-/**
- * Result object for full test session setup.
- */
-export interface TestSessionResult {
-  readonly consoleErrors: ConsoleError[];
-  readonly networkErrors: NetworkError[];
-}
-
-/**
- * Result object for test session validation.
- */
-export interface ValidationResult {
-  readonly consoleValidation: {
-    allErrorsAllowed: boolean;
-    nonAllowedErrors: ConsoleError[];
-    totalErrors: number;
-    allowedErrors: number;
-  };
-  readonly networkValidation: {
-    allErrorsAllowed: boolean;
-    nonAllowedErrors: NetworkError[];
-    totalErrors: number;
-    allowedErrors: number;
-  };
-  readonly summary: string;
-}
-
-/**
- * LCS integration detection result.
- */
-export interface LCSDetectionResult {
-  readonly lcsIntegrationActive: boolean;
-  readonly workerDetected: boolean;
-  readonly bundleSize?: number;
-  readonly hasLCSMessages: boolean;
-  readonly hasStubFallback: boolean;
-  readonly hasErrorIndicators: boolean;
-  readonly summary: string;
-}
-
-/**
- * Sets up a complete test session with monitoring, workspace, and extension activation.
- * This consolidates the common setup pattern used across all tests.
- *
- * @param page - Playwright page instance
- * @returns Object containing error monitoring arrays
- */
-export const setupFullTestSession = async (
-  page: Page,
-): Promise<TestSessionResult> => {
-  // Setup test workspace
-  await setupTestWorkspace();
-
-  // Set up monitoring
-  const consoleErrors = setupConsoleMonitoring(page);
-  const networkErrors = setupNetworkMonitoring(page);
-
-  // Install early worker detection before any navigation
-  setupWorkerResponseHook(page);
-
-  // Execute core test steps
-  await startVSCodeWeb(page);
-  await verifyWorkspaceFiles(page);
-  await activateExtension(page);
-  await waitForLSPInitialization(page);
-
-  return { consoleErrors, networkErrors };
-};
-
-/**
- * Performs comprehensive validation of test session results.
- * Consolidates error validation and reporting logic.
- *
- * @param consoleErrors - Console errors collected during test
- * @param networkErrors - Network errors collected during test
- * @returns Validation results with summary
- */
-export const performStrictValidation = (
-  consoleErrors: ConsoleError[],
-  networkErrors: NetworkError[],
-): ValidationResult => {
-  const consoleValidation = validateAllErrorsInAllowList(consoleErrors);
-  const networkValidation = validateAllNetworkErrorsInAllowList(networkErrors);
-
-  let summary = '📊 Validation Results:\n';
-  summary += `   - Console errors: ${consoleValidation.totalErrors} (${consoleValidation.allowedErrors} allowed, `;
-  summary += `${consoleValidation.nonAllowedErrors.length} blocked)\n`;
-  summary += `   - Network errors: ${networkValidation.totalErrors} (${networkValidation.allowedErrors} allowed, `;
-  summary += `${networkValidation.nonAllowedErrors.length} blocked)\n`;
-  const passed =
-    consoleValidation.allErrorsAllowed && networkValidation.allErrorsAllowed;
-  summary += `   - Overall status: ${passed ? '✅ PASSED' : '❌ FAILED'}`;
-
-  if (consoleValidation.nonAllowedErrors.length > 0) {
-    summary += '\n❌ Non-allowed console errors:';
-    consoleValidation.nonAllowedErrors.forEach((error, index) => {
-      summary += `\n  ${index + 1}. "${error.text}" (URL: ${error.url ?? 'no URL'})`;
-    });
-  }
-
-  if (networkValidation.nonAllowedErrors.length > 0) {
-    summary += '\n❌ Non-allowed network errors:';
-    networkValidation.nonAllowedErrors.forEach((error, index) => {
-      summary += `\n  ${index + 1}. HTTP ${error.status} ${error.url} (${error.description})`;
-    });
-  }
-
-  return { consoleValidation, networkValidation, summary };
-};
-
-/**
- * Detects LCS integration status by analyzing console messages and worker behavior.
- * Consolidates LCS detection logic from multiple test files.
- *
- * @param page - Playwright page instance
- * @returns LCS detection results
- */
-export const detectLCSIntegration = async (
-  page: Page,
-): Promise<LCSDetectionResult> => {
-  const consoleMessages: string[] = [];
-  const lcsMessages: string[] = [];
-  const workerMessages: string[] = [];
-
-  // Enhanced console monitoring for LCS detection
-  page.on('console', (msg) => {
-    const text = msg.text();
-    consoleMessages.push(text);
-
-    if (text.includes('LCS') || text.includes('LSP-Compliant-Services')) {
-      lcsMessages.push(text);
-    }
-
-    if (text.includes('Worker') || text.includes('worker')) {
-      workerMessages.push(text);
-    }
-  });
-
-  // Wait for LCS initialization by checking for worker messages or console indicators
-  await page
-    .waitForFunction(
-      () => {
-        const messages = performance
-          .getEntriesByType('resource')
-          .some(
-            (entry: any) =>
-              entry.name.includes('worker.js') &&
-              entry.name.includes('devextensions'),
-          );
-        return messages || window.console;
-      },
-      { timeout: 8000 },
-    )
-    .catch(() => {
-      // If function-based wait fails, continue - this is informational
-    });
-
-  // Analyze console messages for LCS indicators
-  const hasStubFallback = consoleMessages.some(
-    (msg) =>
-      msg.includes('stub mode') ||
-      msg.includes('fallback') ||
-      msg.includes('Stub implementation'),
-  );
-
-  const hasLCSSuccess = consoleMessages.some(
-    (msg) =>
-      msg.includes('LCS Adapter') ||
-      msg.includes('LCS integration') ||
-      msg.includes('✅ Apex Language Server Worker with LCS ready'),
-  );
-
-  const hasErrorIndicators = consoleMessages.some(
-    (msg) =>
-      msg.includes('❌ Failed to start LCS') ||
-      msg.includes('🔄 Falling back to stub'),
-  );
-
-  // Check for worker detection
-  let workerDetected = false;
-  let bundleSize: number | undefined;
-
-  try {
-    // Read from early hook store if present
-    const early = workerDetectionStore.get(page);
-    if (early) {
-      workerDetected = workerDetected ?? early.workerDetected;
-      bundleSize = bundleSize ?? early.bundleSize;
-    }
-
-    // Inspect already-loaded resources via Performance API
-    const perfWorker = await page.evaluate(() => {
-      const entries = performance.getEntriesByType('resource') as any[];
-      const workerEntry = entries.find(
-        (e) => e.name.includes('worker.js') && e.name.includes('devextensions'),
-      );
-      return workerEntry
-        ? { url: workerEntry.name, size: workerEntry.transferSize ?? 0 }
-        : null;
-    });
-    if (perfWorker) {
-      workerDetected = true;
-      if (!bundleSize && perfWorker.size) bundleSize = perfWorker.size;
-    }
-  } catch (_error) {
-    // Ignore worker detection errors
-  }
-
-  const lcsIntegrationActive =
-    hasLCSSuccess || (!hasStubFallback && !hasErrorIndicators);
-
-  const bundleSizeMB = bundleSize
-    ? `${Math.round((bundleSize / 1024 / 1024) * 100) / 100} MB`
-    : 'Unknown';
-
-  let summary = '🔍 LCS Integration Analysis:\n';
-  summary += `   - LCS Integration: ${lcsIntegrationActive ? '✅ ACTIVE' : '❌ INACTIVE'}\n`;
-  summary += `   - Worker Detected: ${workerDetected ? '✅ YES' : '❌ NO'}\n`;
-  summary += `   - Bundle Size: ${bundleSizeMB}\n`;
-  summary += `   - LCS Messages: ${lcsMessages.length}\n`;
-  summary += `   - Stub Fallback: ${hasStubFallback ? '⚠️ YES' : '✅ NO'}\n`;
-  summary += `   - Error Indicators: ${hasErrorIndicators ? '❌ YES' : '✅ NO'}`;
-
-  return {
-    lcsIntegrationActive,
-    workerDetected,
-    bundleSize,
-    hasLCSMessages: lcsMessages.length > 0,
-    hasStubFallback,
-    hasErrorIndicators,
-    summary,
-  };
-};
-
-/**
- * Waits for LCS services to be ready by checking for completion functionality.
- * Replaces unreliable setTimeout calls with deterministic waiting.
- *
- * @param page - Playwright page instance
- */
-export const waitForLCSReady = async (page: Page): Promise<void> => {
-  try {
-    // Wait for editor to be ready
-    const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
-    await monacoEditor.waitFor({ state: 'visible', timeout: 15000 });
-
-    // Try to trigger completion to test LCS services
-    await monacoEditor.click();
-    await positionCursorInConstructor(page);
-    await page.keyboard.type('System.');
-
-    // Wait for completion suggestion or timeout
-    await page
-      .waitForSelector('.suggest-widget, .monaco-list, [id*="suggest"]', {
-        timeout: 5000,
-      })
-      .catch(() => {
-        // Completion might not appear immediately, continue
-      });
-
-    // Clean up the typed text
-    await page.keyboard.press('Control+Z'); // Undo the typing
-  } catch (_error) {
-    // If LCS readiness check fails, continue - this is informational
-    console.log('ℹ️ LCS readiness check completed with minor issues');
-  }
-};
-
 /**
- * Tests basic LSP language services functionality with simple, direct checks.
- * No fallback mechanisms - fails clearly if functionality doesn't work.
- *
- * @param page - Playwright page instance
- * @returns Object indicating which LSP features are working
+ * Main test helpers module - re-exports all utilities from focused sub-modules.
+ *
+ * This file maintains backward compatibility while providing access to the new
+ * modular architecture. All existing imports should continue to work unchanged.
+ *
+ * Module Structure:
+ * - error-handling.ts: Error validation, handling, and monitoring utilities
+ * - worker-detection.ts: LCS worker detection and analysis
+ * - vscode-interaction.ts: VS Code UI interaction and navigation
+ * - lsp-testing.ts: Language Server Protocol testing utilities
+ * - test-reporting.ts: Test result reporting and configuration
+ * - test-orchestration.ts: High-level test coordination and setup
+ */
+
+// Re-export everything from error handling module
+export {
+  ErrorValidator,
+  ErrorHandler,
+  WaitingStrategies,
+  setupConsoleMonitoring,
+  setupNetworkMonitoring,
+  filterCriticalErrors,
+  validateAllErrorsInAllowList,
+  validateAllNetworkErrorsInAllowList,
+  type ErrorValidationConfig,
+  type ErrorValidationResult,
+  type WaitOptions,
+  type ErrorHandlingOptions,
+} from './error-handling';
+
+// Re-export everything from worker detection module
+export {
+  WorkerDetectionService,
+  detectLCSIntegration,
+  setupWorkerResponseHook,
+  type WorkerInfo,
+  type PerformanceResourceEntry,
+  type LCSDetectionResult,
+} from './worker-detection';
+
+// Re-export everything from VS Code interaction module
+export {
+  startVSCodeWeb,
+  verifyWorkspaceFiles,
+  activateExtension,
+  waitForLSPInitialization,
+  verifyVSCodeStability,
+  verifyApexFileContentLoaded,
+  ALL_SAMPLE_FILES,
+  type SampleFile,
+  type TestSessionResult,
+} from './vscode-interaction';
+
+// Re-export everything from LSP testing module
+export {
+  waitForLCSReady,
+  testLSPFunctionality,
+  positionCursorOnWord,
+  triggerHover,
+  testHoverScenario,
+  executeHoverTestScenarios,
+  detectOutlineSymbols,
+  type HoverTestScenario,
+  type HoverTestResult,
+  type LSPFunctionalityResult,
+} from './lsp-testing';
+
+// Re-export everything from test reporting module
+export {
+  TestConfiguration,
+  TestResultReporter,
+  performStrictValidation,
+  type ValidationResult,
+} from './test-reporting';
+
+// Re-export everything from test orchestration module
+export {
+  setupFullTestSession,
+  setupApexTestEnvironment,
+  type ExtendedTestSessionResult,
+  type TestSessionOptions,
+} from './test-orchestration';
+
+/**
+ * @deprecated Use the new modular imports for better organization.
+ * This main file will continue to work but consider importing from specific modules:
+ *
+ * @example
+ * // Instead of:
+ * import { ErrorHandler, TestConfiguration } from './test-helpers';
+ *
+ * // Consider:
+ * import { ErrorHandler } from './error-handling';
+ * import { TestConfiguration } from './test-reporting';
+ *
+ * This provides better code organization and clearer dependencies.
  */
-export const testLSPFunctionality = async (
-  page: Page,
-): Promise<{
-  completionTested: boolean;
-  symbolsTested: boolean;
-  editorResponsive: boolean;
-}> => {
-  const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
-
-  // Test editor responsiveness
-  await monacoEditor.click();
-  const editorResponsive = await monacoEditor.isVisible();
-
-  // Test completion services - System.debug should always work in Apex
-  await positionCursorInConstructor(page);
-  await page.keyboard.type('System.');
-  await page.keyboard.press('ControlOrMeta+Space');
-
-  const completionWidget = page.locator(
-    '.suggest-widget.visible, .monaco-list[aria-label*="suggest"], [aria-label*="IntelliSense"]',
-  );
-
-  let completionTested = false;
-  try {
-    await completionWidget.waitFor({ state: 'visible', timeout: 3000 });
-    completionTested = await completionWidget.isVisible();
-    if (completionTested) {
-      await page.keyboard.press('Escape'); // Close completion
-    }
-  } catch {
-    // Completion not available
-    completionTested = false;
-  }
-
-  // Clean up typed text
-  await page.keyboard.press('Control+Z');
-
-  // Test document symbols - use single approach, no fallbacks
-  let symbolsTested = false;
-  try {
-    await page.keyboard.press('ControlOrMeta+Shift+O');
-    const symbolPicker = page.locator(
-      '.quick-input-widget, [id*="quickInput"]',
-    );
-    await symbolPicker.waitFor({ state: 'visible', timeout: 2000 });
-
-    const symbolItems = page.locator('.quick-input-widget .monaco-list-row');
-    const itemCount = await symbolItems.count();
-    symbolsTested = itemCount > 0;
-
-    if (symbolsTested) {
-      await page.keyboard.press('Escape'); // Close symbol picker
-    }
-  } catch {
-    // Document symbols not available
-    symbolsTested = false;
-  }
-
-  return { completionTested, symbolsTested, editorResponsive };
-};
-
-/**
- * Positions the cursor inside the constructor method of the ApexClassExample class.
- * This provides a proper context for testing completion services.
- *
- * @param page - Playwright page instance
- */
-export const positionCursorInConstructor = async (
-  page: Page,
-): Promise<void> => {
-  try {
-    // Use Ctrl+F to find the constructor method
-    await page.keyboard.press('Control+F');
-    // Wait for find input to appear
-    await page
-      .waitForSelector('input[aria-label="Find"], .find-widget', {
-        timeout: 1500,
-      })
-      .catch(() => {});
-
-    // Search for the constructor method signature
-    await page.keyboard.type('this.instanceId = instanceId;');
-    await page.keyboard.press('Enter'); // Search
-    await page.keyboard.press('Escape'); // Close search dialog
-
-    // Position cursor at the end of the constructor method, before the closing brace
-    await page.keyboard.press('End');
-    await page.keyboard.press('Enter'); // Add new line
-    await page.keyboard.type('        '); // Add proper indentation (8 spaces to match constructor body)
-  } catch (_error) {
-    console.log(
-      '⚠️ Could not position cursor in constructor, using default position',
-    );
-    // Fallback to end of file if constructor positioning fails
-    await page.keyboard.press('Control+End');
-    await page.keyboard.type('\n    ');
-  }
-};
diff --git a/e2e-tests/utils/test-orchestration.ts b/e2e-tests/utils/test-orchestration.ts
new file mode 100644
index 00000000..927389f4
--- /dev/null
+++ b/e2e-tests/utils/test-orchestration.ts
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { Page } from '@playwright/test';
+import { setupTestWorkspace } from './setup';
+import {
+  startVSCodeWeb,
+  verifyWorkspaceFiles,
+  activateExtension,
+  waitForLSPInitialization,
+  verifyApexFileContentLoaded,
+  type TestSessionResult,
+} from './vscode-interaction';
+import {
+  setupConsoleMonitoring,
+  setupNetworkMonitoring,
+} from './error-handling';
+import {
+  setupWorkerResponseHook,
+  detectLCSIntegration,
+  type LCSDetectionResult,
+} from './worker-detection';
+import { waitForLCSReady } from './lsp-testing';
+
+/**
+ * Extended test session result with LCS detection.
+ */
+export interface ExtendedTestSessionResult extends TestSessionResult {
+  readonly lcsDetection?: LCSDetectionResult;
+}
+
+/**
+ * Options for test session setup.
+ */
+export interface TestSessionOptions {
+  readonly includeLCSDetection?: boolean;
+  readonly expectedContent?: string;
+  readonly skipLCSReady?: boolean;
+}
+
+/**
+ * Sets up a complete test session with monitoring, workspace, and extension activation.
+ * This consolidates the common setup pattern used across all tests.
+ *
+ * @param page - Playwright page instance
+ * @returns Object containing error monitoring arrays
+ */
+export const setupFullTestSession = async (
+  page: Page,
+): Promise<TestSessionResult> => {
+  // Setup test workspace
+  await setupTestWorkspace();
+
+  // Set up monitoring
+  const consoleErrors = setupConsoleMonitoring(page);
+  const networkErrors = setupNetworkMonitoring(page);
+
+  // Install early worker detection before any navigation
+  setupWorkerResponseHook(page);
+
+  // Execute core test steps
+  await startVSCodeWeb(page);
+  await verifyWorkspaceFiles(page);
+  await activateExtension(page);
+  await waitForLSPInitialization(page);
+
+  return { consoleErrors, networkErrors };
+};
+
+/**
+ * Sets up a complete Apex test environment with all common initialization steps.
+ * Consolidates the repeated setup pattern from all test cases.
+ *
+ * @param page - Playwright page instance
+ * @param options - Setup options
+ * @returns Extended test session result with optional LCS detection
+ */
+export const setupApexTestEnvironment = async (
+  page: Page,
+  options: TestSessionOptions = {},
+): Promise<ExtendedTestSessionResult> => {
+  const {
+    includeLCSDetection = false,
+    expectedContent = 'ApexClassExample',
+    skipLCSReady = false,
+  } = options;
+
+  // Setup complete test session
+  const sessionResult = await setupFullTestSession(page);
+
+  // Verify Apex file content is loaded
+  await verifyApexFileContentLoaded(page, expectedContent);
+
+  // Wait for LCS services to be ready (unless skipped)
+  if (!skipLCSReady) {
+    await waitForLCSReady(page);
+  }
+
+  // Optionally detect LCS integration (expensive operation)
+  let lcsDetection: LCSDetectionResult | undefined;
+  if (includeLCSDetection) {
+    lcsDetection = await detectLCSIntegration(page);
+  }
+
+  return {
+    ...sessionResult,
+    lcsDetection,
+  };
+};
diff --git a/e2e-tests/utils/test-reporting.ts b/e2e-tests/utils/test-reporting.ts
new file mode 100644
index 00000000..155757c5
--- /dev/null
+++ b/e2e-tests/utils/test-reporting.ts
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { ConsoleError, NetworkError } from './constants';
+import type { ErrorValidationResult } from './error-handling';
+import type { LCSDetectionResult } from './worker-detection';
+import type { LSPFunctionalityResult, HoverTestScenario } from './lsp-testing';
+import {
+  validateAllErrorsInAllowList,
+  validateAllNetworkErrorsInAllowList,
+} from './error-handling';
+
+/**
+ * Result object for test session validation.
+ */
+export interface ValidationResult {
+  readonly consoleValidation: ErrorValidationResult<ConsoleError>;
+  readonly networkValidation: ErrorValidationResult<NetworkError>;
+  readonly summary: string;
+}
+
+/**
+ * Test configuration for centralized settings.
+ */
+export class TestConfiguration {
+  // Bundle size thresholds
+  static readonly MIN_LCS_BUNDLE_SIZE_MB = 5;
+  static readonly MAX_BUNDLE_SIZE_MB = 50;
+
+  // Timeout configurations
+  static readonly DEFAULT_LSP_TIMEOUT = 15000;
+  static readonly DEFAULT_HOVER_TIMEOUT = 1500;
+  static readonly DEFAULT_SYMBOL_TIMEOUT = 5000;
+
+  // Test expectations
+  static readonly MIN_EXPECTED_SYMBOLS = 2;
+  static readonly EXPECTED_APEX_FILE = 'ApexClassExample';
+
+  // Performance thresholds
+  static readonly MAX_SETUP_TIME_MS = 60000;
+  static readonly MAX_TEST_DURATION_MS = 120000;
+
+  /**
+   * Validates bundle size against LCS expectations.
+   */
+  static validateBundleSize(bundleSize: number): {
+    isValid: boolean;
+    sizeInMB: number;
+    meetsLCSThreshold: boolean;
+  } {
+    const sizeInMB = bundleSize / 1024 / 1024;
+    const meetsLCSThreshold = sizeInMB >= this.MIN_LCS_BUNDLE_SIZE_MB;
+    const isValid = sizeInMB <= this.MAX_BUNDLE_SIZE_MB;
+
+    return {
+      isValid,
+      sizeInMB,
+      meetsLCSThreshold,
+    };
+  }
+
+  /**
+   * Gets adaptive timeout based on environment.
+   */
+  static getAdaptiveTimeout(baseTimeout: number): number {
+    // Increase timeout in CI environments
+    const multiplier = process.env.CI ? 2 : 1;
+    return baseTimeout * multiplier;
+  }
+}
+
+/**
+ * Test result reporter for standardized logging and assertions.
+ */
+export class TestResultReporter {
+  /**
+   * Reports LCS detection results with standardized formatting.
+   */
+  static reportLCSDetection(lcsDetection: LCSDetectionResult): void {
+    console.log(lcsDetection.summary);
+
+    if (lcsDetection.bundleSize) {
+      const sizeInMB = lcsDetection.bundleSize / 1024 / 1024;
+      console.log(
+        `✅ Bundle size confirms LCS integration: ${sizeInMB.toFixed(2)} MB`,
+      );
+    }
+  }
+
+  /**
+   * Reports LSP functionality test results.
+   */
+  static reportLSPFunctionality(
+    lspFunctionality: LSPFunctionalityResult,
+  ): void {
+    console.log('🔧 LSP Functionality Test Results:');
+    console.log(
+      `   - Editor Responsive: ${lspFunctionality.editorResponsive ? '✅' : '❌'}`,
+    );
+    console.log(
+      `   - Completion Tested: ${lspFunctionality.completionTested ? '✅' : '❌'}`,
+    );
+    console.log(
+      `   - Symbols Tested: ${lspFunctionality.symbolsTested ? '✅' : '❌'}`,
+    );
+  }
+
+  /**
+   * Reports validation results with detailed error information.
+   */
+  static reportValidation(validation: ValidationResult): void {
+    console.log(validation.summary);
+  }
+
+  /**
+   * Reports symbol validation results with detailed findings.
+   */
+  static reportSymbolValidation(
+    symbolValidation: any,
+    expectedSymbols: string[],
+    foundSymbols: string[],
+    totalItems: number,
+  ): void {
+    console.log('🎉 LCS Type Parsing and Outline View test COMPLETED');
+    console.log('   - File: ✅ ApexClassExample.cls opened and loaded');
+    console.log('   - Extension: ✅ Language features activated');
+    console.log('   - LCS Integration: ✅ Active and functional');
+    console.log('   - Outline: ✅ Outline view loaded and accessible');
+    console.log(
+      `     • Class: ${symbolValidation.classFound ? '✅' : '❌'} ApexClassExample`,
+    );
+    console.log(
+      `     • Types parsed: ${foundSymbols.length}/${expectedSymbols.length} (${foundSymbols.join(', ')})`,
+    );
+    console.log(`   - Total outline elements: ${totalItems}`);
+    console.log(
+      '   ✨ This test validates LCS integration and comprehensive type parsing',
+    );
+  }
+
+  /**
+   * Reports hover test results with success/failure summary.
+   */
+  static reportHoverResults(
+    hoverResults: Array<{ scenario: HoverTestScenario; success: boolean }>,
+  ): void {
+    const successCount = hoverResults.filter((r) => r.success).length;
+    const totalCount = hoverResults.length;
+
+    console.log(
+      `🔍 Hover Test Results: ${successCount}/${totalCount} scenarios passed`,
+    );
+
+    hoverResults.forEach((result, index) => {
+      const status = result.success ? '✅' : '❌';
+      console.log(`   ${index + 1}. ${status} ${result.scenario.description}`);
+    });
+  }
+}
+
+/**
+ * Performs comprehensive validation of test session results.
+ * Consolidates error validation and reporting logic.
+ *
+ * @param consoleErrors - Console errors collected during test
+ * @param networkErrors - Network errors collected during test
+ * @returns Validation results with summary
+ */
+export const performStrictValidation = (
+  consoleErrors: ConsoleError[],
+  networkErrors: NetworkError[],
+): ValidationResult => {
+  const consoleValidation = validateAllErrorsInAllowList(consoleErrors);
+  const networkValidation = validateAllNetworkErrorsInAllowList(networkErrors);
+
+  let summary = '📊 Validation Results:\n';
+  summary += `   - Console errors: ${consoleValidation.totalErrors} (${consoleValidation.allowedErrors} allowed, `;
+  summary += `${consoleValidation.nonAllowedErrors.length} blocked)\n`;
+  summary += `   - Network errors: ${networkValidation.totalErrors} (${networkValidation.allowedErrors} allowed, `;
+  summary += `${networkValidation.nonAllowedErrors.length} blocked)\n`;
+  const passed =
+    consoleValidation.allErrorsAllowed && networkValidation.allErrorsAllowed;
+  summary += `   - Overall status: ${passed ? '✅ PASSED' : '❌ FAILED'}`;
+
+  if (consoleValidation.nonAllowedErrors.length > 0) {
+    summary += '\n❌ Non-allowed console errors:';
+    consoleValidation.nonAllowedErrors.forEach((error, index) => {
+      summary += `\n  ${index + 1}. "${error.text}" (URL: ${error.url || 'no URL'})`;
+    });
+  }
+
+  if (networkValidation.nonAllowedErrors.length > 0) {
+    summary += '\n❌ Non-allowed network errors:';
+    networkValidation.nonAllowedErrors.forEach((error, index) => {
+      summary += `\n  ${index + 1}. HTTP ${error.status} ${error.url} (${error.description})`;
+    });
+  }
+
+  return { consoleValidation, networkValidation, summary };
+};
diff --git a/e2e-tests/utils/vscode-interaction.ts b/e2e-tests/utils/vscode-interaction.ts
new file mode 100644
index 00000000..b935f7df
--- /dev/null
+++ b/e2e-tests/utils/vscode-interaction.ts
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { Page } from '@playwright/test';
+import { SELECTORS, APEX_CLASS_EXAMPLE_CONTENT } from './constants';
+import { setupWorkerResponseHook } from './worker-detection';
+import {
+  setupConsoleMonitoring,
+  setupNetworkMonitoring,
+} from './error-handling';
+import type { ConsoleError, NetworkError } from './constants';
+
+/**
+ * Test sample file type definition.
+ */
+export interface SampleFile {
+  readonly filename: string;
+  readonly content: string;
+}
+
+/**
+ * Result object for full test session setup.
+ */
+export interface TestSessionResult {
+  readonly consoleErrors: ConsoleError[];
+  readonly networkErrors: NetworkError[];
+}
+
+/**
+ * Creates a sample file object for testing.
+ *
+ * @param filename - The file name with extension
+ * @param content - The file content
+ * @returns Sample file object for test workspace
+ */
+const createSampleFile = (filename: string, content: string): SampleFile => ({
+  filename,
+  content,
+});
+
+/**
+ * Creates the comprehensive Apex class example file.
+ *
+ * @returns Sample file with comprehensive Apex class content
+ */
+const createApexClassExampleFile = (): SampleFile =>
+  createSampleFile('ApexClassExample.cls', APEX_CLASS_EXAMPLE_CONTENT);
+
+/**
+ * All sample files for workspace creation.
+ */
+export const ALL_SAMPLE_FILES = [createApexClassExampleFile()] as const;
+
+/**
+ * Starts VS Code Web and waits for it to load.
+ *
+ * @param page - Playwright page instance
+ */
+export const startVSCodeWeb = async (page: Page): Promise<void> => {
+  await page.goto('/', { waitUntil: 'networkidle' });
+
+  // Wait for the page to be fully loaded
+  await page.waitForLoadState('domcontentloaded');
+
+  // Wait for VS Code workbench to be fully loaded and interactive
+  await page.waitForSelector(SELECTORS.STATUSBAR, {
+    timeout: 60_000, // VS Code startup timeout
+  });
+
+  // Verify VS Code workbench loaded
+  await page.waitForSelector(SELECTORS.WORKBENCH, {
+    timeout: 30_000, // Selector wait timeout
+  });
+  const workbench = page.locator(SELECTORS.WORKBENCH);
+  await workbench.waitFor({ state: 'visible' });
+
+  // Ensure the workbench is fully interactive
+  await page.waitForLoadState('networkidle');
+};
+
+/**
+ * Verifies workspace files are loaded.
+ *
+ * @param page - Playwright page instance
+ * @returns Number of Apex files found
+ */
+export const verifyWorkspaceFiles = async (page: Page): Promise<number> => {
+  const explorer = page.locator(SELECTORS.EXPLORER);
+  await explorer.waitFor({ state: 'visible', timeout: 30_000 });
+
+  // Wait for the file system to stabilize in CI environments
+  if (process.env.CI) {
+    // Wait for explorer content to be fully loaded instead of using timeout
+    await page
+      .waitForFunction(
+        () => {
+          const explorer = document.querySelector(
+            '[id="workbench.view.explorer"]',
+          );
+          return explorer && explorer.children.length > 0;
+        },
+        { timeout: 5000 },
+      )
+      .catch(() => {
+        // If the function-based wait fails, use a short fallback
+      });
+  }
+
+  // Check if our test files are visible (Apex files)
+  const apexFiles = page.locator(SELECTORS.APEX_FILE_ICON);
+  const fileCount = await apexFiles.count();
+
+  return fileCount;
+};
+
+/**
+ * Opens an Apex file to activate the extension.
+ *
+ * @param page - Playwright page instance
+ */
+export const activateExtension = async (page: Page): Promise<void> => {
+  const clsFile = page.locator(SELECTORS.CLS_FILE_ICON).first();
+
+  await clsFile.waitFor({
+    state: 'visible',
+    timeout: 15_000,
+  });
+
+  if (await clsFile.isVisible()) {
+    // Hover to show file selection in debug mode
+    if (process.env.DEBUG_MODE) {
+      await clsFile.hover();
+      await page
+        .waitForSelector(SELECTORS.CLS_FILE_ICON + ':hover', { timeout: 1000 })
+        .catch(() => {
+          // Ignore hover selector timeout - it's just for debug visibility
+        });
+    }
+
+    await clsFile.click();
+  } else {
+    throw new Error('No .cls file found to activate extension');
+  }
+
+  // Wait for editor to load
+  await page.waitForSelector(SELECTORS.EDITOR_PART, { timeout: 15_000 });
+  const editorPart = page.locator(SELECTORS.EDITOR_PART);
+  await editorPart.waitFor({ state: 'visible' });
+
+  // Verify Monaco editor is present
+  const monacoEditor = page.locator(SELECTORS.MONACO_EDITOR);
+  await monacoEditor.waitFor({ state: 'visible', timeout: 30_000 });
+
+  // Verify that file content is actually loaded in the editor
+  const editorText = page.locator('.monaco-editor .view-lines');
+  await editorText.waitFor({ state: 'visible', timeout: 5_000 });
+
+  // Check if the editor contains some text content
+  const hasContent = await editorText.locator('.view-line').first().isVisible();
+  if (!hasContent) {
+    throw new Error(
+      'Extension activated but file content may not be loaded yet',
+    );
+  }
+};
+
+/**
+ * Waits for LSP server to initialize.
+ *
+ * @param page - Playwright page instance
+ */
+export const waitForLSPInitialization = async (page: Page): Promise<void> => {
+  // Wait for Monaco editor to be ready and responsive
+  await page.waitForSelector(
+    SELECTORS.MONACO_EDITOR + ' .monaco-editor-background',
+    {
+      timeout: 30_000, // LSP initialization timeout
+    },
+  );
+
+  // Wait for any language server activity by checking for syntax highlighting or symbols
+  await page.evaluate(
+    async () =>
+      new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          const editor = document.querySelector('.monaco-editor .view-lines');
+          if (editor && editor.children.length > 0) {
+            clearInterval(checkInterval);
+            resolve(true);
+          }
+        }, 100);
+
+        // Timeout after 8 seconds
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve(true);
+        }, 8000);
+      }),
+  );
+};
+
+/**
+ * Verifies VS Code stability by checking core UI elements.
+ *
+ * @param page - Playwright page instance
+ */
+export const verifyVSCodeStability = async (page: Page): Promise<void> => {
+  const sidebar = page.locator(SELECTORS.SIDEBAR);
+  await sidebar.waitFor({ state: 'visible' });
+
+  const statusbar = page.locator(SELECTORS.STATUSBAR);
+  await statusbar.waitFor({ state: 'visible' });
+};
+
+/**
+ * Verifies that Apex code content is loaded and visible in the editor.
+ * Throws an error if content is not loaded or doesn't match expectations.
+ *
+ * @param page - Playwright page instance
+ * @param expectedContent - Optional specific content to look for
+ * @throws Error if content is not visible or doesn't match expectations
+ */
+export const verifyApexFileContentLoaded = async (
+  page: Page,
+  expectedContent?: string,
+): Promise<void> => {
+  try {
+    // Wait for editor content to load
+    const editorContent = page.locator('.monaco-editor .view-lines .view-line');
+    await editorContent.first().waitFor({ state: 'visible', timeout: 5_000 });
+
+    // Get the visible text content
+    const firstLineText = await editorContent.first().textContent();
+    const hasApexKeywords =
+      firstLineText &&
+      (firstLineText.includes('public') ||
+        firstLineText.includes('class') ||
+        firstLineText.includes('private') ||
+        firstLineText.includes('static'));
+
+    if (expectedContent) {
+      const allText = await editorContent.allTextContents();
+      const fullText = allText.join(' ');
+      const hasExpectedContent = fullText.includes(expectedContent);
+
+      if (hasExpectedContent) {
+        return;
+      } else {
+        throw new Error(
+          `Expected content "${expectedContent}" not found in editor`,
+        );
+      }
+    }
+
+    if (hasApexKeywords) {
+      return;
+    } else {
+      throw new Error('Editor content does not contain recognizable Apex code');
+    }
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      (error.message.includes('Expected content') ||
+        error.message.includes('Editor content does not contain'))
+    ) {
+      throw error; // Re-throw our custom errors
+    }
+    throw new Error(`Could not verify editor content: ${error}`);
+  }
+};
diff --git a/e2e-tests/utils/worker-detection.ts b/e2e-tests/utils/worker-detection.ts
new file mode 100644
index 00000000..e964e741
--- /dev/null
+++ b/e2e-tests/utils/worker-detection.ts
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the
+ * repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { Page } from '@playwright/test';
+
+/**
+ * Worker information interface.
+ */
+export interface WorkerInfo {
+  readonly detected: boolean;
+  readonly bundleSize?: number;
+  readonly url?: string;
+}
+
+/**
+ * Performance resource entry interface.
+ */
+export interface PerformanceResourceEntry {
+  readonly name: string;
+  readonly transferSize?: number;
+}
+
+/**
+ * LCS integration detection result.
+ */
+export interface LCSDetectionResult {
+  readonly lcsIntegrationActive: boolean;
+  readonly workerDetected: boolean;
+  readonly bundleSize?: number;
+  readonly hasLCSMessages: boolean;
+  readonly hasStubFallback: boolean;
+  readonly hasErrorIndicators: boolean;
+  readonly summary: string;
+}
+
+/**
+ * Worker detection service for managing LCS worker detection.
+ */
+export class WorkerDetectionService {
+  private static readonly detectionStore: WeakMap<Page, WorkerInfo> =
+    new WeakMap();
+
+  /**
+   * Checks if a URL is a worker URL.
+   */
+  private static isWorkerUrl(url: string): boolean {
+    return (
+      (url.includes('worker.js') ||
+        url.includes('worker.global.js') ||
+        url.includes('server-bundle')) &&
+      (url.includes('devextensions') ||
+        url.includes('static') ||
+        url.includes('extension'))
+    );
+  }
+
+  /**
+   * Sets up early response hook to capture worker bundle fetch.
+   */
+  static setupResponseHook(page: Page): void {
+    const initial: WorkerInfo = { detected: false };
+    this.detectionStore.set(page, initial);
+
+    page.on('response', async (response) => {
+      const url = response.url();
+      if (!this.isWorkerUrl(url)) return;
+
+      try {
+        const buffer = await response.body();
+        const workerInfo: WorkerInfo = {
+          detected: true,
+          bundleSize: buffer.length,
+          url,
+        };
+        this.detectionStore.set(page, workerInfo);
+      } catch (_error) {
+        // Ignore size measurement errors
+        const workerInfo: WorkerInfo = { detected: true, url };
+        this.detectionStore.set(page, workerInfo);
+      }
+    });
+  }
+
+  /**
+   * Detects worker from Performance API.
+   */
+  static async detectFromPerformanceAPI(page: Page): Promise<WorkerInfo> {
+    try {
+      const perfWorker = await page.evaluate(() => {
+        const entries = performance.getEntriesByType(
+          'resource',
+        ) as PerformanceResourceEntry[];
+        const workerEntry = entries.find(
+          (e) =>
+            (e.name.includes('worker.js') ||
+              e.name.includes('worker.global.js') ||
+              e.name.includes('server-bundle')) &&
+            (e.name.includes('devextensions') ||
+              e.name.includes('static') ||
+              e.name.includes('extension')),
+        );
+        return workerEntry
+          ? { url: workerEntry.name, size: workerEntry.transferSize || 0 }
+          : null;
+      });
+
+      if (perfWorker) {
+        return {
+          detected: true,
+          bundleSize: perfWorker.size,
+          url: perfWorker.url,
+        };
+      }
+
+      // Additional check: Look for large extension files
+      const extensionWorkers = await page.evaluate(() => {
+        const entries = performance.getEntriesByType(
+          'resource',
+        ) as PerformanceResourceEntry[];
+        return entries
+          .filter(
+            (e) =>
+              e.name.includes('extension') &&
+              (e.name.includes('.js') || e.name.includes('.mjs')) &&
+              (e.transferSize || 0) > 1000000, // Large files are likely worker bundles (>1MB)
+          )
+          .map((e) => ({ url: e.name, size: e.transferSize || 0 }));
+      });
+
+      if (extensionWorkers.length > 0) {
+        return {
+          detected: true,
+          bundleSize: extensionWorkers[0].size,
+          url: extensionWorkers[0].url,
+        };
+      }
+
+      return { detected: false };
+    } catch (_error) {
+      return { detected: false };
+    }
+  }
+
+  /**
+   * Gets worker detection result for a page.
+   */
+  static getDetectionResult(page: Page): WorkerInfo {
+    return this.detectionStore.get(page) || { detected: false };
+  }
+
+  /**
+   * Comprehensive worker detection combining multiple strategies.
+   */
+  static async detectWorker(page: Page): Promise<WorkerInfo> {
+    // Check early hook store first
+    const early = this.getDetectionResult(page);
+    if (early.detected) {
+      return early;
+    }
+
+    // Fallback to Performance API detection
+    return this.detectFromPerformanceAPI(page);
+  }
+}
+
+/**
+ * Detects LCS integration status by analyzing console messages and worker behavior.
+ * Consolidates LCS detection logic from multiple test files.
+ *
+ * @param page - Playwright page instance
+ * @returns LCS detection results
+ */
+export const detectLCSIntegration = async (
+  page: Page,
+): Promise<LCSDetectionResult> => {
+  const consoleMessages: string[] = [];
+  const lcsMessages: string[] = [];
+  const workerMessages: string[] = [];
+
+  // Enhanced console monitoring for LCS detection
+  page.on('console', (msg) => {
+    const text = msg.text();
+    consoleMessages.push(text);
+
+    if (text.includes('LCS') || text.includes('LSP-Compliant-Services')) {
+      lcsMessages.push(text);
+    }
+
+    if (text.includes('Worker') || text.includes('worker')) {
+      workerMessages.push(text);
+    }
+  });
+
+  // Wait for LCS initialization by checking for worker messages or console indicators
+  await page
+    .waitForFunction(
+      () => {
+        const entries = performance.getEntriesByType(
+          'resource',
+        ) as PerformanceResourceEntry[];
+        const messages = entries.some(
+          (entry) =>
+            (entry.name.includes('worker.js') ||
+              entry.name.includes('worker.global.js') ||
+              entry.name.includes('server-bundle')) &&
+            (entry.name.includes('devextensions') ||
+              entry.name.includes('static') ||
+              entry.name.includes('extension')),
+        );
+        return messages || window.console;
+      },
+      { timeout: 8000 },
+    )
+    .catch(() => {
+      // If function-based wait fails, continue - this is informational
+    });
+
+  // Analyze console messages for LCS indicators
+  const hasStubFallback = consoleMessages.some(
+    (msg) =>
+      msg.includes('stub mode') ||
+      msg.includes('fallback') ||
+      msg.includes('Stub implementation'),
+  );
+
+  const hasLCSSuccess = consoleMessages.some(
+    (msg) =>
+      msg.includes('LCS Adapter') ||
+      msg.includes('LCS integration') ||
+      msg.includes('✅ Apex Language Server Worker with LCS ready'),
+  );
+
+  const hasErrorIndicators = consoleMessages.some(
+    (msg) =>
+      msg.includes('❌ Failed to start LCS') ||
+      msg.includes('🔄 Falling back to stub'),
+  );
+
+  // Check for worker detection using the service
+  const workerInfo = await WorkerDetectionService.detectWorker(page);
+  const workerDetected = workerInfo.detected;
+  const bundleSize = workerInfo.bundleSize;
+
+  const lcsIntegrationActive =
+    hasLCSSuccess || (!hasStubFallback && !hasErrorIndicators);
+
+  const bundleSizeMB = bundleSize
+    ? `${Math.round((bundleSize / 1024 / 1024) * 100) / 100} MB`
+    : 'Unknown';
+
+  let summary = '🔍 LCS Integration Analysis:\n';
+  summary += `   - LCS Integration: ${lcsIntegrationActive ? '✅ ACTIVE' : '❌ INACTIVE'}\n`;
+  summary += `   - Worker Detected: ${workerDetected ? '✅ YES' : '❌ NO'}\n`;
+  summary += `   - Bundle Size: ${bundleSizeMB}\n`;
+  summary += `   - LCS Messages: ${lcsMessages.length}\n`;
+  summary += `   - Stub Fallback: ${hasStubFallback ? '⚠️ YES' : '✅ NO'}\n`;
+  summary += `   - Error Indicators: ${hasErrorIndicators ? '❌ YES' : '✅ NO'}`;
+
+  return {
+    lcsIntegrationActive,
+    workerDetected,
+    bundleSize,
+    hasLCSMessages: lcsMessages.length > 0,
+    hasStubFallback,
+    hasErrorIndicators,
+    summary,
+  };
+};
+
+/**
+ * Install an early response hook to capture worker bundle fetch before navigation.
+ */
+export const setupWorkerResponseHook = (page: Page): void => {
+  WorkerDetectionService.setupResponseHook(page);
+};
diff --git a/package-lock.json b/package-lock.json
index 3861f4b0..02c53347 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -82,6 +82,10 @@
     },
     "e2e-tests": {
       "version": "1.0.0",
+      "dependencies": {
+        "express": "^5.1.0",
+        "http-proxy-middleware": "^3.0.5"
+      },
       "devDependencies": {
         "@playwright/test": "^1.55.0",
         "@types/node": "^20.11.30",
@@ -4529,6 +4533,15 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/http-proxy": {
+      "version": "1.17.16",
+      "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.16.tgz",
+      "integrity": "sha512-sdWoUajOB1cd0A8cRRQ1cfyWNbmFKLAqBB89Y8x5iYyG/mkJHc0YUH8pdWBy2omi9qtCpiIgGjuwO0dQST2l5w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/istanbul-lib-coverage": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
@@ -4604,7 +4617,6 @@
       "version": "20.19.17",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.17.tgz",
       "integrity": "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
@@ -6323,6 +6335,38 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/body-parser": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.6.3",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/body-parser/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/boolbase": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
@@ -6350,7 +6394,6 @@
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "fill-range": "^7.1.1"
@@ -6597,6 +6640,15 @@
         "esbuild": ">=0.18"
       }
     },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/cac": {
       "version": "6.7.14",
       "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
@@ -7168,7 +7220,6 @@
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
       "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.6"
@@ -7282,6 +7333,24 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
     "node_modules/cookies": {
       "version": "0.9.1",
       "resolved": "https://registry.npmjs.org/cookies/-/cookies-0.9.1.tgz",
@@ -7791,7 +7860,6 @@
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
       "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -8020,7 +8088,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
       "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -8295,7 +8362,6 @@
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
       "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/effect": {
@@ -8369,7 +8435,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
       "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -8805,7 +8870,6 @@
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
       "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/escape-string-regexp": {
@@ -9453,6 +9517,21 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT"
+    },
     "node_modules/events": {
       "version": "3.3.0",
       "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
@@ -9571,6 +9650,112 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
+    "node_modules/express": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.0",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express/node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express/node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express/node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/express/node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express/node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express/node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/external-editor": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
@@ -9787,7 +9972,6 @@
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "to-regex-range": "^5.0.1"
@@ -9796,6 +9980,23 @@
         "node": ">=8"
       }
     },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/find-node-modules": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/find-node-modules/-/find-node-modules-2.1.3.tgz",
@@ -9924,7 +10125,6 @@
       "version": "1.15.11",
       "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
       "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
-      "dev": true,
       "funding": [
         {
           "type": "individual",
@@ -10004,6 +10204,15 @@
         "node": ">= 6"
       }
     },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/fresh": {
       "version": "0.5.2",
       "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
@@ -10896,7 +11105,6 @@
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
       "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "depd": "2.0.0",
@@ -10909,6 +11117,20 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/http-proxy": {
+      "version": "1.18.1",
+      "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz",
+      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
+      "license": "MIT",
+      "dependencies": {
+        "eventemitter3": "^4.0.0",
+        "follow-redirects": "^1.0.0",
+        "requires-port": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/http-proxy-agent": {
       "version": "7.0.2",
       "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
@@ -10923,6 +11145,23 @@
         "node": ">= 14"
       }
     },
+    "node_modules/http-proxy-middleware": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-3.0.5.tgz",
+      "integrity": "sha512-GLZZm1X38BPY4lkXA01jhwxvDoOkkXqjgVyUzVxiEK4iuRu03PZoYHhHRwxnfhQMDuaxi3vVri0YgSro/1oWqg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-proxy": "^1.17.15",
+        "debug": "^4.3.6",
+        "http-proxy": "^1.18.1",
+        "is-glob": "^4.0.3",
+        "is-plain-object": "^5.0.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+      }
+    },
     "node_modules/https-proxy-agent": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
@@ -11157,7 +11396,6 @@
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/ini": {
@@ -11272,6 +11510,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/is-arguments": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz",
@@ -11458,7 +11705,6 @@
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -11523,7 +11769,6 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "is-extglob": "^2.1.1"
@@ -11618,7 +11863,6 @@
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.12.0"
@@ -11661,6 +11905,15 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/is-potential-custom-element-name": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
@@ -11668,6 +11921,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -14439,7 +14698,6 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
       "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -14680,6 +14938,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/merge-stream": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
@@ -14701,7 +14971,6 @@
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
       "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "braces": "^3.0.3",
@@ -14715,7 +14984,6 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -14978,7 +15246,6 @@
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/mute-stream": {
@@ -18610,7 +18877,6 @@
       "version": "2.4.1",
       "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
       "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ee-first": "1.1.1"
@@ -18633,7 +18899,6 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
       "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dev": true,
       "license": "ISC",
       "dependencies": {
         "wrappy": "1"
@@ -19083,7 +19348,6 @@
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
       "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -19160,7 +19424,6 @@
       "version": "8.3.0",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz",
       "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==",
-      "dev": true,
       "license": "MIT",
       "funding": {
         "type": "opencollective",
@@ -19714,6 +19977,19 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/proxy-from-env": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
@@ -19866,6 +20142,46 @@
         "safe-buffer": "^5.1.0"
       }
     },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.1.tgz",
+      "integrity": "sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.7.0",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/raw-body/node_modules/iconv-lite": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+      "integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/rc": {
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
@@ -20237,6 +20553,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
+      "license": "MIT"
+    },
     "node_modules/resolve": {
       "version": "1.22.10",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
@@ -20560,6 +20882,22 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/rrweb-cssom": {
       "version": "0.8.0",
       "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
@@ -20655,7 +20993,6 @@
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "dev": true,
       "funding": [
         {
           "type": "github",
@@ -20718,7 +21055,6 @@
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/sax": {
@@ -24041,6 +24377,73 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/send/node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/send/node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -24101,7 +24504,6 @@
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
       "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/sha.js": {
@@ -24606,7 +25008,6 @@
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
       "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -25300,7 +25701,6 @@
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "is-number": "^7.0.0"
@@ -25313,7 +25713,6 @@
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
       "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.6"
@@ -25895,7 +26294,6 @@
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
       "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "content-type": "^1.0.5",
@@ -25910,7 +26308,6 @@
       "version": "1.54.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
       "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.6"
@@ -25920,7 +26317,6 @@
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
       "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "mime-db": "^1.54.0"
@@ -26101,7 +26497,6 @@
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
       "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/unicode-emoji-modifier-base": {
@@ -26160,6 +26555,15 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/update-browserslist-db": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
@@ -26314,7 +26718,6 @@
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
       "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
@@ -26705,7 +27108,6 @@
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/write-file-atomic": {
diff --git a/package.json b/package.json
index 74fafa6f..d2ec8307 100644
--- a/package.json
+++ b/package.json
@@ -16,10 +16,10 @@
     "test:coverage:report": "node scripts/merge-coverage.js",
     "test:integration": "turbo run test:integration",
     "test:web": "node scripts/test-web-ext.js web",
-    "test:e2e": "turbo run rebuild && turbo run test --filter=e2e-tests",
-    "test:e2e:debug": "turbo run rebuild && turbo run test:debug --filter=e2e-tests",
-    "test:e2e:server": "turbo run rebuild && turbo run server --filter=e2e-tests",
-    "test:e2e:visual": "turbo run rebuild && turbo run test:visual --filter=e2e-tests",
+    "test:e2e": "turbo run test --filter=e2e-tests",
+    "test:e2e:debug": "turbo run test:debug --filter=e2e-tests",
+    "test:e2e:server": "turbo run server --filter=e2e-tests",
+    "test:e2e:visual": "turbo run test:visual --filter=e2e-tests",
     "lint": "turbo run lint",
     "lint:fix": "turbo run lint:fix",
     "compile": "turbo run compile",
diff --git a/packages/apex-lsp-testbed/src/servers/jorje/javaServerLauncher.ts b/packages/apex-lsp-testbed/src/servers/jorje/javaServerLauncher.ts
index 57f6f50d..91717590 100644
--- a/packages/apex-lsp-testbed/src/servers/jorje/javaServerLauncher.ts
+++ b/packages/apex-lsp-testbed/src/servers/jorje/javaServerLauncher.ts
@@ -348,8 +348,9 @@ export const createJavaServerOptions = async (
       args.push(
         '-Dtrace.protocol=false',
         `-Dapex.lsp.root.log.level=${logLevel}`,
-         
-        `-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspendStartup ? 'y' : 'n'},address=*:${debugPort},quiet=y`,
+        `-agentlib:jdwp=transport=dt_socket,server=y,suspend=${
+          suspendStartup ? 'y' : 'n'
+        },address=*:${debugPort},quiet=y`,
       );
     }
 
diff --git a/packages/apex-lsp-vscode-extension/src/error-handling.ts b/packages/apex-lsp-vscode-extension/src/error-handling.ts
index d7426359..ca212128 100644
--- a/packages/apex-lsp-vscode-extension/src/error-handling.ts
+++ b/packages/apex-lsp-vscode-extension/src/error-handling.ts
@@ -47,8 +47,9 @@ export const handleAutoRestart = async (
       10000,
     );
     logToOutputChannel(
-       
-      `Will retry server start (${getServerStartRetries()}/${EXTENSION_CONSTANTS.MAX_RETRIES}) after ${delay}ms delay...`,
+      `Will retry server start (${getServerStartRetries()}/${
+        EXTENSION_CONSTANTS.MAX_RETRIES
+      }) after ${delay}ms delay...`,
       'info',
     );
 
diff --git a/packages/apex-parser-ast/package.json b/packages/apex-parser-ast/package.json
index c973ed13..540353f0 100644
--- a/packages/apex-parser-ast/package.json
+++ b/packages/apex-parser-ast/package.json
@@ -30,7 +30,7 @@
     "test": "jest",
     "test:one": "jest --testPathPattern=resourceLoader",
     "test:coverage": "jest --coverage --coverageDirectory=./coverage",
-    "clean": "rimraf out dist .turbo coverage src/generated resources tsconfig.tsbuildinfo",
+    "clean": "rimraf out dist .turbo coverage src/generated tsconfig.tsbuildinfo",
     "clean:all": "npm run clean && rimraf node_modules",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix"
diff --git a/packages/custom-services/package.json b/packages/custom-services/package.json
index 8ebcfd38..9d08da2f 100644
--- a/packages/custom-services/package.json
+++ b/packages/custom-services/package.json
@@ -20,7 +20,7 @@
     "compile": "tsc --build",
     "bundle": "tsup",
     "test": "jest --passWithNoTests",
-    "test:coverage": "jest --coverage --coverageDirectory=./coverage",
+    "test:coverage": "jest --coverage --coverageDirectory=./coverage --passWithNoTests",
     "clean": "rimraf out dist .turbo coverage tsconfig.tsbuildinfo",
     "clean:all": "npm run clean && rimraf node_modules",
     "lint": "eslint src",
diff --git a/packages/lsp-compliant-services/src/index.ts b/packages/lsp-compliant-services/src/index.ts
index 3e469b7b..55dac2f3 100644
--- a/packages/lsp-compliant-services/src/index.ts
+++ b/packages/lsp-compliant-services/src/index.ts
@@ -161,7 +161,9 @@ export const dispatchProcessOnHover = async (
 ): Promise<Hover | null> => {
   const logger = getLogger();
   logger.debug(
-    `🔍 [dispatchProcessOnHover] Dispatching hover request for ${params.textDocument.uri} at ${params.position.line}:${params.position.character}`,
+    `🔍 [dispatchProcessOnHover] Dispatching hover request for ${
+      params.textDocument.uri
+    } at ${params.position.line}:${params.position.character}`,
   );
 
   // Use singleton pattern to ensure same symbol manager instance
@@ -174,7 +176,9 @@ export const dispatchProcessOnHover = async (
   }
   const result = await hoverHandlerInstance.handleHover(params);
   logger.debug(
-    `✅ [dispatchProcessOnHover] Hover dispatch completed for ${params.textDocument.uri}: ${result ? 'success' : 'null'}`,
+    `✅ [dispatchProcessOnHover] Hover dispatch completed for ${
+      params.textDocument.uri
+    }: ${result ? 'success' : 'null'}`,
   );
   return result;
 };