aria-ease 6.14.0 → 7.0.0

package/dist/src/utils/test/contractTestRunnerPlaywright-5FIGA5G4.js

@@ -1,1372 +0,0 @@
-import { ContractReporter, normalizeStrictness, createTestPage, normalizeLevel, resolveEnforcement } from './chunk-4DU5Z5BR.js';
-import { RelativeTargetResolver } from './chunk-GLT43UVH.js';
-import { readFileSync } from 'fs';
-import path2 from 'path';
-import { pathToFileURL } from 'url';
-import { expect } from '@playwright/test';
-
-var StrategyRegistry = class {
-  builtInStrategies = /* @__PURE__ */ new Map();
-  constructor() {
-    this.registerBuiltInStrategies();
-  }
-  /**
-   * Register built-in strategies
-   */
-  registerBuiltInStrategies() {
-    this.builtInStrategies.set(
-      "menu",
-      () => import('./MenuComponentStrategy-6XWU5KLW.js').then(
-        (m) => m.MenuComponentStrategy
-      )
-    );
-    this.builtInStrategies.set(
-      "accordion",
-      () => import('./AccordionComponentStrategy-WRHZOEN6.js').then(
-        (m) => m.AccordionComponentStrategy
-      )
-    );
-    this.builtInStrategies.set(
-      "combobox",
-      () => import('./ComboboxComponentStrategy-XKQ72RFD.js').then(
-        (m) => m.ComboboxComponentStrategy
-      )
-    );
-    this.builtInStrategies.set(
-      "tabs",
-      () => import('./TabsComponentStrategy-BKG53SEV.js').then(
-        (m) => m.TabsComponentStrategy
-      )
-    );
-  }
-  /**
-   * Load a strategy - either from custom path or built-in registry
-   * @param componentName - Component name (e.g., "menu", "accordion")
-   * @param customStrategyPath - Optional custom strategy file path
-   * @returns Strategy constructor function or null if not found
-   */
-  async loadStrategy(componentName, customStrategyPath, configBaseDir) {
-    try {
-      if (customStrategyPath) {
-        try {
-          const resolvedCustomPath = path2.isAbsolute(customStrategyPath) ? customStrategyPath : path2.resolve(configBaseDir || process.cwd(), customStrategyPath);
-          const customModule = await import(pathToFileURL(resolvedCustomPath).href);
-          const strategy = customModule.default || customModule;
-          if (!strategy) {
-            throw new Error(`No default export found in ${customStrategyPath}`);
-          }
-          return strategy;
-        } catch (error) {
-          throw new Error(
-            `Failed to load custom strategy from ${customStrategyPath}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      const builtInLoader = this.builtInStrategies.get(componentName);
-      if (!builtInLoader) {
-        return null;
-      }
-      return builtInLoader();
-    } catch (error) {
-      throw new Error(
-        `Strategy loading failed for ${componentName}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /**
-   * Check if a strategy exists (either built-in or custom path provided)
-   */
-  has(componentName, customStrategyPath) {
-    return !!customStrategyPath || this.builtInStrategies.has(componentName);
-  }
-};
-
-// src/utils/test/src/ComponentDetector.ts
-var ComponentDetector = class {
-  static strategyRegistry = new StrategyRegistry();
-  static isComponentConfig(value) {
-    return typeof value === "object" && value !== null;
-  }
-  /**
-   * Detect and instantiate a component strategy
-   * Supports:
-   * - Built-in strategies (menu, accordion, combobox, tabs)
-   * - Custom strategies via config (strategyPath)
-   * - Custom contract paths via config (path)
-   * @param componentName - Component name
-   * @param componentConfig - Component config from ariaease.config.js
-   * @param actionTimeoutMs - Action timeout in milliseconds
-   * @param assertionTimeoutMs - Assertion timeout in milliseconds
-   * @returns Instantiated ComponentStrategy or null
-   */
-  static async detect(componentName, componentConfig, actionTimeoutMs = 400, assertionTimeoutMs = 400, configBaseDir) {
-    const typedComponentConfig = this.isComponentConfig(componentConfig) ? componentConfig : void 0;
-    const contractPath = typedComponentConfig?.contractPath;
-    if (!contractPath) {
-      throw new Error(`Contract path not found for component: ${componentName}`);
-    }
-    const resolvedPath = (() => {
-      if (path2.isAbsolute(contractPath)) return contractPath;
-      if (configBaseDir) {
-        const configResolved = path2.resolve(configBaseDir, contractPath);
-        try {
-          readFileSync(configResolved, "utf-8");
-          return configResolved;
-        } catch {
-        }
-      }
-      const cwdResolved = path2.resolve(process.cwd(), contractPath);
-      try {
-        readFileSync(cwdResolved, "utf-8");
-        return cwdResolved;
-      } catch {
-        return new URL(contractPath, import.meta.url).pathname;
-      }
-    })();
-    const contractData = readFileSync(resolvedPath, "utf-8");
-    const componentContract = JSON.parse(contractData);
-    const selectors = componentContract.selectors;
-    const strategyClass = await this.strategyRegistry.loadStrategy(
-      componentName,
-      typedComponentConfig?.strategyPath,
-      configBaseDir
-    );
-    if (!strategyClass) {
-      return null;
-    }
-    const mainSelector = selectors.main;
-    if (componentName === "tabs") {
-      return new strategyClass(mainSelector, selectors);
-    }
-    return new strategyClass(
-      mainSelector,
-      selectors,
-      actionTimeoutMs,
-      assertionTimeoutMs
-    );
-  }
-};
-
-// src/utils/test/src/ActionExecutor.ts
-var ActionExecutor = class {
-  constructor(page, selectors, timeoutMs = 400) {
-    this.page = page;
-    this.selectors = selectors;
-    this.timeoutMs = timeoutMs;
-  }
-  /**
-   * Check if error is due to browser/page being closed
-   */
-  isBrowserClosedError(error) {
-    return error instanceof Error && error.message.includes("Target page, context or browser has been closed");
-  }
-  /**
-   * Execute focus action
-   */
-  /**
-   * Execute focus action (supports absolute, relative, and virtual focus)
-   * @param target - selector key (e.g. "input", "button", "relative", or "virtual")
-   * @param relativeTarget - for relative focus (e.g. "first", "last")
-   * @param virtualId - for virtual focus (aria-activedescendant value)
-   */
-  async focus(target, relativeTarget, virtualId) {
-    try {
-      if (target === "virtual" && virtualId) {
-        const mainSelector = this.selectors.main;
-        if (!mainSelector) {
-          return { success: false, error: `Main selector not defined for virtual focus.` };
-        }
-        const main = this.page.locator(mainSelector).first();
-        const exists = await main.count();
-        if (!exists) {
-          return { success: false, error: `Main element not found for virtual focus.` };
-        }
-        await main.evaluate((el, id) => {
-          el.setAttribute("aria-activedescendant", id);
-        }, virtualId);
-        return { success: true };
-      }
-      if (target === "relative" && relativeTarget) {
-        const relativeSelector = this.selectors.relative;
-        if (!relativeSelector) {
-          return { success: false, error: `Relative selector not defined for focus action.` };
-        }
-        const element = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
-        if (!element) {
-          return { success: false, error: `Could not resolve relative target ${relativeTarget} for focus.` };
-        }
-        await element.focus({ timeout: this.timeoutMs });
-        return { success: true };
-      }
-      const selector = this.selectors[target];
-      if (!selector) {
-        return { success: false, error: `Selector for focus target ${target} not found.` };
-      }
-      await this.page.locator(selector).first().focus({ timeout: this.timeoutMs });
-      return { success: true };
-    } catch (error) {
-      if (this.isBrowserClosedError(error)) {
-        return {
-          success: false,
-          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
-          shouldBreak: true
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to focus ${target}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Execute type/fill action
-   */
-  async type(target, value) {
-    try {
-      const selector = this.selectors[target];
-      if (!selector) {
-        return { success: false, error: `Selector for type target ${target} not found.` };
-      }
-      await this.page.locator(selector).first().fill(value, { timeout: this.timeoutMs });
-      return { success: true };
-    } catch (error) {
-      if (this.isBrowserClosedError(error)) {
-        return {
-          success: false,
-          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
-          shouldBreak: true
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to type into ${target}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Execute click action
-   */
-  async click(target, relativeTarget) {
-    try {
-      if (target === "document") {
-        await this.page.mouse.click(10, 10);
-        return { success: true };
-      }
-      if (target === "relative" && relativeTarget) {
-        const relativeSelector = this.selectors.relative;
-        if (!relativeSelector) {
-          return { success: false, error: `Relative selector not defined for click action.` };
-        }
-        const element = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
-        if (!element) {
-          return { success: false, error: `Could not resolve relative target ${relativeTarget} for click.` };
-        }
-        await element.click({ timeout: this.timeoutMs });
-        return { success: true };
-      }
-      const selector = this.selectors[target];
-      if (!selector) {
-        return { success: false, error: `Selector for action target ${target} not found.` };
-      }
-      await this.page.locator(selector).first().click({ timeout: this.timeoutMs });
-      return { success: true };
-    } catch (error) {
-      if (this.isBrowserClosedError(error)) {
-        return {
-          success: false,
-          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
-          shouldBreak: true
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to click ${target}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Execute keypress action
-   */
-  async keypress(target, key) {
-    try {
-      const keyMap = {
-        "Space": "Space",
-        "Enter": "Enter",
-        "Escape": "Escape",
-        "Arrow Up": "ArrowUp",
-        "Arrow Down": "ArrowDown",
-        "Arrow Left": "ArrowLeft",
-        "Arrow Right": "ArrowRight",
-        "Home": "Home",
-        "End": "End",
-        "Tab": "Tab"
-      };
-      let keyValue = keyMap[key] || key;
-      if (keyValue === "Space") {
-        keyValue = " ";
-      } else if (keyValue.includes(" ")) {
-        keyValue = keyValue.replace(/ /g, "");
-      }
-      if (target === "focusable" && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Escape", "Home", "End", "Tab", "Shift+Tab"].includes(keyValue)) {
-        await this.page.keyboard.press(keyValue);
-        return { success: true };
-      }
-      const selector = this.selectors[target];
-      if (!selector) {
-        return { success: false, error: `Selector for keypress target ${target} not found.` };
-      }
-      const locator = this.page.locator(selector).first();
-      const elementCount = await locator.count();
-      if (elementCount === 0) {
-        return {
-          success: false,
-          error: `${target} element not found.`,
-          shouldBreak: true
-          // Signal to skip this test
-        };
-      }
-      await locator.press(keyValue, { timeout: this.timeoutMs });
-      return { success: true };
-    } catch (error) {
-      if (this.isBrowserClosedError(error)) {
-        return {
-          success: false,
-          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
-          shouldBreak: true
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to press ${key} on ${target}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Execute hover action
-   */
-  async hover(target, relativeTarget) {
-    try {
-      if (target === "relative" && relativeTarget) {
-        const relativeSelector = this.selectors.relative;
-        if (!relativeSelector) {
-          return { success: false, error: `Relative selector not defined for hover action.` };
-        }
-        const element = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
-        if (!element) {
-          return { success: false, error: `Could not resolve relative target ${relativeTarget} for hover.` };
-        }
-        await element.hover({ timeout: this.timeoutMs });
-        return { success: true };
-      }
-      const selector = this.selectors[target];
-      if (!selector) {
-        return { success: false, error: `Selector for hover target ${target} not found.` };
-      }
-      await this.page.locator(selector).first().hover({ timeout: this.timeoutMs });
-      return { success: true };
-    } catch (error) {
-      if (this.isBrowserClosedError(error)) {
-        return {
-          success: false,
-          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
-          shouldBreak: true
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to hover ${target}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-};
-var AssertionRunner = class {
-  constructor(page, selectors, timeoutMs = 400) {
-    this.page = page;
-    this.selectors = selectors;
-    this.timeoutMs = timeoutMs;
-  }
-  /**
-   * Resolve the target element for an assertion
-   */
-  async resolveTarget(targetName, relativeTarget, selectorKey) {
-    try {
-      if (targetName === "relative") {
-        const relativeSelector = selectorKey ? this.selectors[selectorKey] : this.selectors.relative;
-        if (!relativeSelector) {
-          return { target: null, error: "Relative selector is not defined in the contract." };
-        }
-        if (!relativeTarget) {
-          return { target: null, error: "Relative target or expected value is not defined." };
-        }
-        const target = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
-        if (!target) {
-          return { target: null, error: `Target ${targetName} not found.` };
-        }
-        return { target };
-      }
-      const selector = this.selectors[targetName];
-      if (!selector) {
-        return { target: null, error: `Selector for assertion target ${targetName} not found.` };
-      }
-      return { target: this.page.locator(selector).first() };
-    } catch (error) {
-      return {
-        target: null,
-        error: `Failed to resolve target ${targetName}: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Validate visibility assertion
-   */
-  async validateVisibility(target, targetName, expectedVisible, failureMessage, testDescription) {
-    try {
-      if (expectedVisible) {
-        await expect(target).toBeVisible({ timeout: this.timeoutMs });
-        return {
-          success: true,
-          passMessage: `${targetName} is visible as expected. Test: "${testDescription}".`
-        };
-      } else {
-        await expect(target).toBeHidden({ timeout: this.timeoutMs });
-        return {
-          success: true,
-          passMessage: `${targetName} is not visible as expected. Test: "${testDescription}".`
-        };
-      }
-    } catch {
-      const selector = this.selectors[targetName] || "";
-      const debugState = await this.page.evaluate((sel) => {
-        const el = sel ? document.querySelector(sel) : null;
-        if (!el) return "element not found";
-        const styles = window.getComputedStyle(el);
-        return `display:${styles.display}, visibility:${styles.visibility}, opacity:${styles.opacity}`;
-      }, selector);
-      if (expectedVisible) {
-        return {
-          success: false,
-          failMessage: `${failureMessage} (actual: ${debugState})`
-        };
-      } else {
-        return {
-          success: false,
-          failMessage: `${failureMessage} ${targetName} is still visible (actual: ${debugState}).`
-        };
-      }
-    }
-  }
-  /**
-   * Validate attribute assertion
-   */
-  async validateAttribute(target, targetName, attribute, expectedValue, failureMessage, testDescription) {
-    if (expectedValue === "!empty") {
-      const attributeValue2 = await target.getAttribute(attribute);
-      if (attributeValue2 && attributeValue2.trim() !== "") {
-        return {
-          success: true,
-          passMessage: `${targetName} has non-empty "${attribute}". Test: "${testDescription}".`
-        };
-      } else {
-        return {
-          success: false,
-          failMessage: `${failureMessage} ${targetName} "${attribute}" should not be empty, found "${attributeValue2}".`
-        };
-      }
-    }
-    if (typeof expectedValue !== "string") {
-      console.error("[AssertionRunner] expectedValue is not a string:", expectedValue);
-      throw new Error(`AssertionRunner: expectedValue for attribute assertion must be a string, but got: ${JSON.stringify(expectedValue)}`);
-    }
-    const expectedValues = expectedValue.split(" | ").map((v) => v.trim());
-    const attributeValue = await target.getAttribute(attribute);
-    if (attributeValue !== null && expectedValues.includes(attributeValue)) {
-      return {
-        success: true,
-        passMessage: `${targetName} has expected "${attribute}". Test: "${testDescription}".`
-      };
-    } else {
-      return {
-        success: false,
-        failMessage: `${failureMessage} ${targetName} "${attribute}" should be "${expectedValue}", found "${attributeValue}".`
-      };
-    }
-  }
-  /**
-   * Validate input value assertion
-   */
-  async validateValue(target, targetName, expectedValue, failureMessage, testDescription) {
-    const inputValue = await target.inputValue().catch(() => "");
-    if (expectedValue === "!empty") {
-      if (inputValue && inputValue.trim() !== "") {
-        return {
-          success: true,
-          passMessage: `${targetName} has non-empty value. Test: "${testDescription}".`
-        };
-      } else {
-        return {
-          success: false,
-          failMessage: `${failureMessage} ${targetName} value should not be empty, found "${inputValue}".`
-        };
-      }
-    }
-    if (expectedValue === "") {
-      if (inputValue === "") {
-        return {
-          success: true,
-          passMessage: `${targetName} has empty value. Test: "${testDescription}".`
-        };
-      } else {
-        return {
-          success: false,
-          failMessage: `${failureMessage} ${targetName} value should be empty, found "${inputValue}".`
-        };
-      }
-    }
-    if (inputValue === expectedValue) {
-      return {
-        success: true,
-        passMessage: `${targetName} has expected value. Test: "${testDescription}".`
-      };
-    } else {
-      return {
-        success: false,
-        failMessage: `${failureMessage} ${targetName} value should be "${expectedValue}", found "${inputValue}".`
-      };
-    }
-  }
-  /**
-   * Validate focus assertion
-   */
-  async validateFocus(target, targetName, expectedFocus, failureMessage, testDescription) {
-    try {
-      if (expectedFocus) {
-        await expect(target).toBeFocused({ timeout: this.timeoutMs });
-        return {
-          success: true,
-          passMessage: `${targetName} has focus as expected. Test: "${testDescription}".`
-        };
-      } else {
-        await expect(target).not.toBeFocused({ timeout: this.timeoutMs });
-        return {
-          success: true,
-          passMessage: `${targetName} does not have focus as expected. Test: "${testDescription}".`
-        };
-      }
-    } catch {
-      const actualFocus = await this.page.evaluate(() => {
-        const focused = document.activeElement;
-        return focused ? `${focused.tagName}#${focused.id || "no-id"}.${focused.className || "no-class"}` : "no element focused";
-      });
-      return {
-        success: false,
-        failMessage: `${failureMessage} (actual focus: ${actualFocus})`
-      };
-    }
-  }
-  /**
-   * Validate role assertion
-   */
-  async validateRole(target, targetName, expectedRole, failureMessage, testDescription) {
-    const roleValue = await target.getAttribute("role");
-    if (roleValue === expectedRole) {
-      return {
-        success: true,
-        passMessage: `${targetName} has role "${expectedRole}". Test: "${testDescription}".`
-      };
-    } else {
-      return {
-        success: false,
-        failMessage: `${failureMessage} Expected role "${expectedRole}", found "${roleValue}".`
-      };
-    }
-  }
-  /**
-   * Main validation method - routes to specific validators
-   */
-  async validate(assertion, testDescription) {
-    if (this.page.isClosed()) {
-      return {
-        success: false,
-        failMessage: `CRITICAL: Browser/page closed before completing all tests. Increase test timeout or reduce test complexity.`
-      };
-    }
-    const { target, error } = await this.resolveTarget(
-      assertion.target,
-      assertion.relativeTarget || assertion.expectedValue,
-      assertion.selectorKey
-    );
-    if (error || !target) {
-      return { success: false, failMessage: error || `Target ${assertion.target} not found.`, target: null };
-    }
-    if (assertion.target === "input" && assertion.attribute === "aria-activedescendant" && assertion.expectedValue === "!empty" && assertion.relativeTarget && assertion.selectorKey) {
-      const optionLocator = await RelativeTargetResolver.resolve(this.page, this.selectors[assertion.selectorKey], assertion.relativeTarget);
-      const optionId = optionLocator ? await optionLocator.getAttribute("id") : null;
-      const inputId = await target.getAttribute("aria-activedescendant");
-      if (optionId && inputId === optionId) {
-        return {
-          success: true,
-          passMessage: `input[aria-activedescendant] matches id of ${assertion.relativeTarget}(${assertion.selectorKey}). Test: "${testDescription}".`
-        };
-      } else {
-        return {
-          success: false,
-          failMessage: `input[aria-activedescendant] should match id of ${assertion.relativeTarget}(${assertion.selectorKey}), found "${inputId}".`
-        };
-      }
-    }
-    switch (assertion.assertion) {
-      case "toBeVisible":
-        return this.validateVisibility(target, assertion.target, true, assertion.failureMessage || "", testDescription);
-      case "notToBeVisible":
-        return this.validateVisibility(target, assertion.target, false, assertion.failureMessage || "", testDescription);
-      case "toHaveAttribute":
-        if (assertion.attribute && assertion.expectedValue !== void 0) {
-          return this.validateAttribute(
-            target,
-            assertion.target,
-            assertion.attribute,
-            assertion.expectedValue,
-            assertion.failureMessage || "",
-            testDescription
-          );
-        }
-        return { success: false, failMessage: "Missing attribute or expectedValue for toHaveAttribute assertion" };
-      case "toHaveValue":
-        if (assertion.expectedValue !== void 0) {
-          return this.validateValue(target, assertion.target, assertion.expectedValue, assertion.failureMessage || "", testDescription);
-        }
-        return { success: false, failMessage: "Missing expectedValue for toHaveValue assertion" };
-      case "toHaveFocus":
-        return this.validateFocus(target, assertion.target, true, assertion.failureMessage || "", testDescription);
-      case "notToHaveFocus":
-        return this.validateFocus(target, assertion.target, false, assertion.failureMessage || "", testDescription);
-      case "toHaveRole":
-        if (assertion.expectedValue !== void 0) {
-          return this.validateRole(target, assertion.target, assertion.expectedValue, assertion.failureMessage || "", testDescription);
-        }
-        return { success: false, failMessage: "Missing expectedValue for toHaveRole assertion" };
-      default:
-        return { success: false, failMessage: `Unknown assertion type: ${assertion.assertion}` };
-    }
-  }
-};
-
-// src/utils/test/src/contractTestRunnerPlaywright.ts
-async function runContractTestsPlaywright(componentName, url, strictness, config, configBaseDir) {
-  const componentConfig = config?.test?.components?.find((c) => c.name === componentName);
-  const isCustomContract = !!componentConfig?.contractPath;
-  const reporter = new ContractReporter(true, isCustomContract);
-  const defaultTimeouts = { actionTimeoutMs: 400, assertionTimeoutMs: 400, navigationTimeoutMs: 3e4, componentReadyTimeoutMs: 5e3 };
-  const globalDisableTimeouts = config?.test?.disableTimeouts === true;
-  const componentDisableTimeouts = componentConfig?.disableTimeouts === true;
-  const disableTimeouts = componentDisableTimeouts || globalDisableTimeouts;
-  const resolveTimeout = (componentValue, globalValue, fallback) => {
-    if (disableTimeouts) return 0;
-    const value = componentValue ?? globalValue;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-      return fallback;
-    }
-    return value;
-  };
-  const actionTimeoutMs = resolveTimeout(componentConfig?.actionTimeoutMs, config?.test?.actionTimeoutMs, defaultTimeouts.actionTimeoutMs);
-  const assertionTimeoutMs = resolveTimeout(
-    componentConfig?.assertionTimeoutMs,
-    config?.test?.assertionTimeoutMs,
-    defaultTimeouts.assertionTimeoutMs
-  );
-  const navigationTimeoutMs = resolveTimeout(
-    componentConfig?.navigationTimeoutMs,
-    config?.test?.navigationTimeoutMs,
-    defaultTimeouts.navigationTimeoutMs
-  );
-  const componentReadyTimeoutMs = resolveTimeout(
-    componentConfig?.componentReadyTimeoutMs,
-    config?.test?.componentReadyTimeoutMs,
-    defaultTimeouts.componentReadyTimeoutMs
-  );
-  const strictnessMode = normalizeStrictness(strictness);
-  const contractPath = componentConfig?.contractPath;
-  if (!contractPath) {
-    throw new Error(`Contract path not found for component: ${componentName}`);
-  }
-  const resolvedPath = (() => {
-    if (path2.isAbsolute(contractPath)) return contractPath;
-    if (configBaseDir) {
-      const configResolved = path2.resolve(configBaseDir, contractPath);
-      try {
-        readFileSync(configResolved, "utf-8");
-        return configResolved;
-      } catch {
-      }
-    }
-    const cwdResolved = path2.resolve(process.cwd(), contractPath);
-    try {
-      readFileSync(cwdResolved, "utf-8");
-      return cwdResolved;
-    } catch {
-      return new URL(contractPath, import.meta.url).pathname;
-    }
-  })();
-  const contractData = readFileSync(resolvedPath, "utf-8");
-  const componentContract = JSON.parse(contractData);
-  const totalTests = (componentContract.relationships?.length || 0) + (componentContract.static[0]?.assertions.length || 0) + componentContract.dynamic.length;
-  const apgUrl = componentContract.meta?.source?.apg;
-  const failures = [];
-  const warnings = [];
-  const passes = [];
-  const skipped = [];
-  let page = null;
-  const classifyFailure = (message, levelRaw) => {
-    const level = normalizeLevel(levelRaw);
-    const enforcement = resolveEnforcement(level, strictnessMode);
-    if (enforcement === "error") {
-      failures.push(message);
-      return { status: "fail", level, detail: message };
-    }
-    if (enforcement === "warning") {
-      warnings.push(message);
-      return { status: "warn", level, detail: message };
-    }
-    const ignoredMessage = `${message} (ignored by strictness=${strictnessMode}, level=${level})`;
-    skipped.push(ignoredMessage);
-    return { status: "skip", level, detail: ignoredMessage };
-  };
-  try {
-    page = await createTestPage();
-    if (url) {
-      try {
-        await page.goto(url, {
-          waitUntil: "domcontentloaded",
-          timeout: navigationTimeoutMs
-        });
-      } catch (error) {
-        throw new Error(
-          `Failed to navigate to ${url}. Ensure dev server is running and accessible. Original error: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-      await page.addStyleTag({ content: `* { transition: none !important; animation: none !important; }` });
-    }
-    const strategy = await ComponentDetector.detect(componentName, componentConfig, actionTimeoutMs, assertionTimeoutMs, configBaseDir);
-    if (!strategy) {
-      throw new Error(`Unsupported component: ${componentName}`);
-    }
-    const mainSelector = strategy.getMainSelector();
-    if (!mainSelector) {
-      throw new Error(`CRITICAL: No selector found in contract for ${componentName}`);
-    }
-    try {
-      await page.locator(mainSelector).first().waitFor({ state: "attached", timeout: componentReadyTimeoutMs });
-    } catch (error) {
-      throw new Error(
-        `
-\u274C CRITICAL: Component not found on page!
-This usually means:
-  - The component didn't render
-  - The URL is incorrect
-  - The component selector '${mainSelector}' in the contract is wrong
-  - Original error: ${error}`
-      );
-    }
-    reporter.start(componentName, totalTests, apgUrl);
-    if (componentName === "menu" && componentContract.selectors.main) {
-      await page.locator(componentContract.selectors.main).first().waitFor({ state: "visible", timeout: componentReadyTimeoutMs }).catch(() => {
-      });
-    }
-    const hasSubmenuCapability = componentName === "menu" && !!componentContract.selectors.submenuTrigger ? await page.locator(componentContract.selectors.submenuTrigger).count() > 0 : false;
-    const isSubmenuRelation = (rel) => rel.type === "aria-reference" && [rel.from, rel.to].some((name) => ["submenu", "submenuTrigger", "submenuItems"].includes(name || "")) || rel.type === "contains" && [rel.parent, rel.child].some((name) => ["submenu", "submenuTrigger", "submenuItems"].includes(name || ""));
-    let staticPassed = 0;
-    let staticFailed = 0;
-    let staticWarnings = 0;
-    for (const rel of componentContract.relationships || []) {
-      if (strategy && typeof strategy.resetState === "function") {
-        try {
-          await strategy.resetState(page);
-        } catch (err) {
-          warnings.push(`Warning: resetState failed before relationship test: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-      const relationshipLevel = normalizeLevel(rel.level);
-      if (Array.isArray(rel.setup) && rel.setup.length > 0) {
-        let isAllowedType2 = function(t) {
-          return allowedTypes.includes(t);
-        };
-        var isAllowedType = isAllowedType2;
-        const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
-        const relDescription = rel.type === "aria-reference" ? `${rel.from}.${rel.attribute} references ${rel.to}` : `${rel.parent} contains ${rel.child}`;
-        const allowedTypes = ["focus", "type", "click", "keypress", "hover"];
-        const toSetupAction = (a) => ({
-          ...a,
-          type: isAllowedType2(a.type) ? a.type : "click"
-        });
-        const setupActions = rel.setup.map(toSetupAction);
-        const setupResult = await runSetupActions(setupActions, actionExecutor, strategy, page, relDescription, ["submenu", "submenuTrigger", "submenuItems"]);
-        if (setupResult.skip) {
-          skipped.push(setupResult.message || "Setup action skipped");
-          reporter.reportStaticTest(relDescription, "skip", setupResult.message, relationshipLevel);
-          continue;
-        }
-        if (!setupResult.success) {
-          const failure = `Relationship setup failed: ${setupResult.error}`;
-          const outcome = classifyFailure(failure, rel.level);
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-      }
-      if (componentName === "menu" && !hasSubmenuCapability) {
-        const involvesSubmenu = isSubmenuRelation(rel);
-        if (involvesSubmenu) {
-          const relDescription = rel.type === "aria-reference" ? `${rel.from}.${rel.attribute} references ${rel.to}` : `${rel.parent} contains ${rel.child}`;
-          const skipMessage = `Skipping submenu relationship assertion: no submenu capability detected in rendered component.`;
-          skipped.push(skipMessage);
-          reporter.reportStaticTest(relDescription, "skip", skipMessage, relationshipLevel);
-          continue;
-        }
-      }
-      if (rel.type === "aria-reference") {
-        const relDescription = `${rel.from}.${rel.attribute} references ${rel.to}`;
-        const fromSelector = componentContract.selectors[rel.from];
-        const toSelector = componentContract.selectors[rel.to];
-        if (!fromSelector || !toSelector) {
-          const outcome = classifyFailure(
-            `Relationship selector missing: from="${rel.from}" or to="${rel.to}" not found in selectors.`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        const fromTarget = page.locator(fromSelector).first();
-        const toTarget = page.locator(toSelector).first();
-        const fromExists = await fromTarget.count() > 0;
-        const toExists = await toTarget.count() > 0;
-        if (!fromExists || !toExists) {
-          if (componentName === "menu" && isSubmenuRelation(rel)) {
-            const skipMessage = "Skipping submenu relationship assertion in static phase: submenu elements are not present until submenu is opened.";
-            skipped.push(skipMessage);
-            reporter.reportStaticTest(relDescription, "skip", skipMessage, relationshipLevel);
-            continue;
-          }
-          const outcome = classifyFailure(
-            `Relationship target not found: ${!fromExists ? rel.from : rel.to}.`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        const attrValue = await fromTarget.getAttribute(rel.attribute);
-        const toId = await toTarget.getAttribute("id");
-        if (!toId) {
-          const outcome = classifyFailure(
-            `Relationship target "${rel.to}" must have an id for ${rel.attribute} validation.`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        const references = (attrValue || "").split(/\s+/).filter(Boolean);
-        const matches = references.includes(toId);
-        if (!matches) {
-          const outcome = classifyFailure(
-            `Expected ${rel.from} ${rel.attribute} to reference id "${toId}", found "${attrValue || ""}".`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        passes.push(`Relationship valid: ${rel.from}.${rel.attribute} -> ${rel.to} (id=${toId}).`);
-        staticPassed += 1;
-        reporter.reportStaticTest(relDescription, "pass", void 0, relationshipLevel);
-        continue;
-      }
-      if (rel.type === "contains") {
-        const relDescription = `${rel.parent} contains ${rel.child}`;
-        const parentSelector = componentContract.selectors[rel.parent];
-        const childSelector = componentContract.selectors[rel.child];
-        if (!parentSelector || !childSelector) {
-          const outcome = classifyFailure(
-            `Relationship selector missing: parent="${rel.parent}" or child="${rel.child}" not found in selectors.`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        const parent = page.locator(parentSelector).first();
-        const parentExists = await parent.count() > 0;
-        if (!parentExists) {
-          if (componentName === "menu" && isSubmenuRelation(rel)) {
-            const skipMessage = "Skipping submenu relationship assertion in static phase: submenu container is not present until submenu is opened.";
-            skipped.push(skipMessage);
-            reporter.reportStaticTest(relDescription, "skip", skipMessage, relationshipLevel);
-            continue;
-          }
-          const outcome = classifyFailure(`Relationship parent target not found: ${rel.parent}.`, rel.level);
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        const descendants = parent.locator(childSelector);
-        const descendantCount = await descendants.count();
-        if (descendantCount < 1) {
-          if (componentName === "menu" && isSubmenuRelation(rel)) {
-            const skipMessage = "Skipping submenu relationship assertion in static phase: submenu descendants are not present until submenu is opened.";
-            skipped.push(skipMessage);
-            reporter.reportStaticTest(relDescription, "skip", skipMessage, relationshipLevel);
-            continue;
-          }
-          const outcome = classifyFailure(
-            `Expected ${rel.parent} to contain descendant matching selector for ${rel.child}.`,
-            rel.level
-          );
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-        passes.push(`Relationship valid: ${rel.parent} contains ${rel.child}.`);
-        staticPassed += 1;
-        reporter.reportStaticTest(relDescription, "pass", void 0, relationshipLevel);
-      }
-    }
-    async function resolveExpectedValue(expectedValue, selectors, page2, context = {}) {
-      if (!expectedValue || typeof expectedValue !== "object" || !("ref" in expectedValue)) return expectedValue;
-      let refSelector;
-      if (expectedValue.ref === "relative") {
-        if (!expectedValue.relativeTarget || !context.relativeBaseSelector) return void 0;
-        const baseLocator = page2.locator(context.relativeBaseSelector);
-        const count = await baseLocator.count();
-        let idx = 0;
-        if (expectedValue.relativeTarget === "first") idx = 0;
-        else if (expectedValue.relativeTarget === "second") idx = 1;
-        else if (expectedValue.relativeTarget === "last") idx = count - 1;
-        else if (!isNaN(Number(expectedValue.relativeTarget))) idx = Number(expectedValue.relativeTarget);
-        else idx = 0;
-        if (idx < 0 || idx >= count) return void 0;
-        const relElem = baseLocator.nth(idx);
-        return await getPropertyFromLocator(relElem, expectedValue.property || expectedValue.attribute);
-      } else {
-        refSelector = selectors[expectedValue.ref];
-        if (!refSelector) throw new Error(`Selector for ref '${expectedValue.ref}' not found in contract selectors.`);
-        const refLocator = page2.locator(refSelector).first();
-        return await getPropertyFromLocator(refLocator, expectedValue.property || expectedValue.attribute);
-      }
-    }
-    async function getPropertyFromLocator(locator, property) {
-      if (!locator) return void 0;
-      if (!property || property === "id") {
-        return await locator.getAttribute("id") ?? void 0;
-      } else if (property === "class") {
-        return await locator.getAttribute("class") ?? void 0;
-      } else if (property === "textContent") {
-        return await locator.evaluate((el) => el.textContent ?? void 0);
-      } else if (property.startsWith("aria-")) {
-        return await locator.getAttribute(property) ?? void 0;
-      } else if (property.endsWith("*")) {
-        const attrs = await locator.evaluate((el) => {
-          const out = [];
-          for (const attr of Array.from(el.attributes)) {
-            if (attr.name.startsWith("aria-")) out.push(`${attr.name}=${attr.value}`);
-          }
-          return out.join(";");
-        });
-        return attrs;
-      } else {
-        return await locator.getAttribute(property) ?? void 0;
-      }
-    }
-    const staticAssertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
-    async function runSetupActions(setup, actionExecutor, strategy2, page2, description, skipKeywords = []) {
-      if (!Array.isArray(setup) || setup.length === 0) return { success: true };
-      if (strategy2 && typeof strategy2.resetState === "function") {
-        await strategy2.resetState(page2);
-      }
-      for (const setupAct of setup) {
-        let setupResult = { success: true };
-        try {
-          if (setupAct.type === "focus") {
-            if (setupAct.target === "relative" && setupAct.relativeTarget) {
-              setupResult = await actionExecutor.focus("relative", setupAct.relativeTarget);
-            } else {
-              setupResult = await actionExecutor.focus(setupAct.target);
-            }
-          } else if (setupAct.type === "type" && setupAct.value) {
-            setupResult = await actionExecutor.type(setupAct.target, setupAct.value);
-          } else if (setupAct.type === "click") {
-            setupResult = await actionExecutor.click(setupAct.target, setupAct.relativeTarget);
-          } else if (setupAct.type === "keypress" && setupAct.key) {
-            setupResult = await actionExecutor.keypress(setupAct.target, setupAct.key);
-          } else if (setupAct.type === "hover") {
-            setupResult = await actionExecutor.hover(setupAct.target, setupAct.relativeTarget);
-          } else {
-            continue;
-          }
-        } catch (err) {
-          setupResult = { success: false, error: err instanceof Error ? err.message : String(err) };
-        }
-        if (!setupResult.success) {
-          const setupMsg = setupResult.error || "Setup action failed";
-          const isSkip = skipKeywords.some((kw) => description.includes(kw) || setupMsg.includes(kw));
-          if (isSkip) {
-            return { success: false, skip: true, message: `Skipping test - capability not present: ${setupMsg}` };
-          }
-          return { success: false, error: setupMsg };
-        }
-      }
-      return { success: true };
-    }
-    for (const test of componentContract.static[0]?.assertions || []) {
-      if (strategy && typeof strategy.resetState === "function") {
-        try {
-          await strategy.resetState(page);
-        } catch (err) {
-          warnings.push(`Warning: resetState failed before static test: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-      if (test.target === "relative") continue;
-      const staticDescription = `${test.target}${test.attribute ? ` (${test.attribute})` : ""}`;
-      const staticLevel = normalizeLevel(test.level);
-      if (componentName === "menu" && test.target === "submenuTrigger" && !hasSubmenuCapability) {
-        const skipMessage = `Skipping submenu static assertion for ${test.target}: no submenu capability detected in rendered component.`;
-        skipped.push(skipMessage);
-        reporter.reportStaticTest(staticDescription, "skip", skipMessage, staticLevel);
-        continue;
-      }
-      if (Array.isArray(test.setup) && test.setup.length > 0) {
-        let isAllowedType2 = function(t) {
-          return allowedTypes.includes(t);
-        };
-        var isAllowedType = isAllowedType2;
-        const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
-        const allowedTypes = ["focus", "type", "click", "keypress", "hover"];
-        const toSetupAction = (a) => ({
-          ...a,
-          type: isAllowedType2(a.type) ? a.type : "click"
-        });
-        const setupActions = test.setup.map(toSetupAction);
-        const setupResult = await runSetupActions(setupActions, actionExecutor, strategy, page, staticDescription, ["submenu", "submenuTrigger", "submenuItems"]);
-        if (setupResult.skip) {
-          skipped.push(setupResult.message || "Setup action skipped");
-          reporter.reportStaticTest(staticDescription, "skip", setupResult.message, staticLevel);
-          continue;
-        }
-        if (!setupResult.success) {
-          const failure = `Static setup failed: ${setupResult.error}`;
-          const outcome = classifyFailure(failure, test.level);
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
-          continue;
-        }
-      }
-      const targetSelector = componentContract.selectors[test.target];
-      if (!targetSelector) {
-        const failure = `Selector for target ${test.target} not found.`;
-        const outcome = classifyFailure(failure, test.level);
-        if (outcome.status === "fail") staticFailed += 1;
-        if (outcome.status === "warn") staticWarnings += 1;
-        reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
-        continue;
-      }
-      const target = page.locator(targetSelector).first();
-      const exists = await target.count() > 0;
-      if (!exists) {
-        const failure = `Target ${test.target} not found.`;
-        const outcome = classifyFailure(failure, test.level);
-        if (outcome.status === "fail") staticFailed += 1;
-        if (outcome.status === "warn") staticWarnings += 1;
-        reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
-        continue;
-      }
-      const isRedundantCheck = (selector, attrName, expectedVal) => {
-        const attrPattern = new RegExp(`\\[${attrName}(?:=["']?([^\\]"']+)["']?)?\\]`);
-        const match = selector.match(attrPattern);
-        if (!match) return false;
-        if (!expectedVal) return true;
-        const selectorValue = match[1];
-        if (selectorValue) {
-          const expectedValues = expectedVal.split(" | ");
-          return expectedValues.includes(selectorValue);
-        }
-        return false;
-      };
-      let expectedValue = test.expectedValue;
-      if (test.expectedValue && typeof test.expectedValue === "object" && "ref" in test.expectedValue) {
-        const context = {};
-        const relTarget = test.relativeTarget;
-        if (test.expectedValue.ref === "relative" && test.target === "relative" && relTarget) {
-          const baseSel = componentContract.selectors[relTarget];
-          if (!baseSel) throw new Error(`Selector for relativeTarget '${relTarget}' not found in contract selectors.`);
-          context.relativeBaseSelector = baseSel;
-        } else if (test.expectedValue.ref === "relative" && relTarget) {
-          const baseSel = componentContract.selectors[relTarget];
-          if (!baseSel) throw new Error(`Selector for relativeTarget '${relTarget}' not found in contract selectors.`);
-          context.relativeBaseSelector = baseSel;
-        }
-        expectedValue = await resolveExpectedValue(test.expectedValue, componentContract.selectors, page, context);
-        console.log("Expected value in static check", expectedValue);
-      }
-      if (!test.expectedValue) {
-        const attributes = test.attribute.split(" | ");
-        let hasAny = false;
-        let allRedundant = true;
-        for (const attr of attributes) {
-          const attrTrimmed = attr.trim();
-          if (isRedundantCheck(targetSelector, attrTrimmed)) {
-            passes.push(`${attrTrimmed} on ${test.target} verified by selector (already present in: ${targetSelector}).`);
-            hasAny = true;
-            continue;
-          }
-          allRedundant = false;
-          const value = await target.getAttribute(attrTrimmed);
-          if (value !== null) {
-            hasAny = true;
-            break;
-          }
-        }
-        if (!hasAny && !allRedundant) {
-          const failure = test.failureMessage + ` None of the attributes "${test.attribute}" are present.`;
-          const outcome = classifyFailure(failure, test.level);
-          if (outcome.status === "fail") staticFailed += 1;
-          if (outcome.status === "warn") staticWarnings += 1;
-          reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
-        } else if (!allRedundant && hasAny) {
-          passes.push(`At least one of the attributes "${test.attribute}" exists on the element.`);
-          staticPassed += 1;
-          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
-        } else {
-          staticPassed += 1;
-          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
-        }
-      } else {
-        if (isRedundantCheck(targetSelector, test.attribute, typeof expectedValue === "string" ? expectedValue : void 0)) {
-          passes.push(`${test.attribute}="${expectedValue}" on ${test.target} verified by selector (already present in: ${targetSelector}).`);
-          staticPassed += 1;
-          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
-        } else {
-          const valueToCheck = expectedValue ?? "";
-          const result = await staticAssertionRunner.validateAttribute(
-            target,
-            test.target,
-            test.attribute,
-            valueToCheck,
-            test.failureMessage,
-            "Static ARIA Test"
-          );
-          if (result.success && result.passMessage) {
-            passes.push(result.passMessage);
-            staticPassed += 1;
-            reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
-          } else if (!result.success && result.failMessage) {
-            const outcome = classifyFailure(result.failMessage, test.level);
-            if (outcome.status === "fail") staticFailed += 1;
-            if (outcome.status === "warn") staticWarnings += 1;
-            reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
-          }
-        }
-      }
-    }
-    for (const dynamicTest of componentContract.dynamic || []) {
-      if (!page || page.isClosed()) {
-        console.warn(`
-\u26A0\uFE0F  Browser closed - skipping remaining ${componentContract.dynamic.length - componentContract.dynamic.indexOf(dynamicTest)} tests
-`);
-        failures.push(`CRITICAL: Browser/page closed before completing all tests. ${componentContract.dynamic.length - componentContract.dynamic.indexOf(dynamicTest)} tests skipped.`);
-        break;
-      }
-      try {
-        await strategy.resetState(page);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        reporter.error(errorMessage);
-        throw error;
-      }
-      const { setup = [], action, assertions } = dynamicTest;
-      const dynamicLevel = normalizeLevel(dynamicTest.level);
-      const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
-      if (Array.isArray(setup) && setup.length > 0) {
-        let isAllowedType2 = function(t) {
-          return allowedTypes.includes(t);
-        };
-        var isAllowedType = isAllowedType2;
-        const allowedTypes = ["focus", "type", "click", "keypress", "hover"];
-        const toSetupAction = (a) => ({
-          ...a,
-          type: isAllowedType2(a.type) ? a.type : "click"
-        });
-        const setupActions = setup.map(toSetupAction);
-        const setupResult = await runSetupActions(setupActions, actionExecutor, strategy, page, dynamicTest.description, ["submenu", "submenuTrigger", "submenuItems"]);
-        if (setupResult.skip) {
-          skipped.push(setupResult.message || "Setup action skipped");
-          reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "skip", setupResult.message);
-          continue;
-        }
-        if (!setupResult.success) {
-          const outcome = classifyFailure(`Setup failed: ${setupResult.error}`, dynamicTest.level);
-          reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, outcome.status, outcome.detail);
-          continue;
-        }
-      }
-      const failuresBeforeTest = failures.length;
-      const warningsBeforeTest = warnings.length;
-      const skippedBeforeTest = skipped.length;
-      const shouldSkipTest = await strategy.shouldSkipTest(dynamicTest, page);
-      if (shouldSkipTest) {
-        const skipMessage = `Skipping test - component-specific conditions not met`;
-        skipped.push(skipMessage);
-        reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "skip", skipMessage);
-        continue;
-      }
-      const assertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
-      let shouldAbortCurrentTest = false;
-      let actionOutcome = null;
-      for (const act of action) {
-        if (!page || page.isClosed()) {
-          failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-          shouldAbortCurrentTest = true;
-          break;
-        }
-        let result;
-        if (act.type === "focus") {
-          if (act.target === "relative" && act.relativeTarget) {
-            result = await actionExecutor.focus("relative", act.relativeTarget);
-          } else {
-            result = await actionExecutor.focus(act.target);
-          }
-        } else if (act.type === "type" && act.value) {
-          result = await actionExecutor.type(act.target, act.value);
-        } else if (act.type === "click") {
-          result = await actionExecutor.click(act.target, act.relativeTarget);
-        } else if (act.type === "keypress" && act.key) {
-          result = await actionExecutor.keypress(act.target, act.key);
-        } else if (act.type === "hover") {
-          result = await actionExecutor.hover(act.target, act.relativeTarget);
-        } else {
-          continue;
-        }
-        if (!result.success) {
-          if (result.error) {
-            const outcome = classifyFailure(result.error, dynamicTest.level);
-            actionOutcome = { status: outcome.status, detail: outcome.detail };
-          }
-          shouldAbortCurrentTest = true;
-          break;
-        }
-      }
-      if (shouldAbortCurrentTest) {
-        reporter.reportTest(
-          { description: dynamicTest.description, level: dynamicLevel },
-          actionOutcome?.status || "fail",
-          actionOutcome?.detail || failures[failures.length - 1]
-        );
-        continue;
-      }
-      for (const assertion of assertions) {
-        let expectedValue;
-        if (assertion.expectedValue && typeof assertion.expectedValue === "object" && "ref" in assertion.expectedValue) {
-          if (assertion.expectedValue.ref === "relative") {
-            const { RelativeTargetResolver: RelativeTargetResolver2 } = await import('./RelativeTargetResolver-G2XDN2VV.js');
-            const relativeSelector = componentContract.selectors.relative;
-            if (!relativeSelector) throw new Error("Relative selector not defined in contract selectors.");
-            const relTarget = assertion.relativeTarget || "first";
-            const relElem = await RelativeTargetResolver2.resolve(page, relativeSelector, relTarget);
-            if (!relElem) throw new Error(`Could not resolve relative target '${relTarget}' for expectedValue.`);
-            const prop = assertion.expectedValue.property || assertion.expectedValue.attribute || "id";
-            if (prop === "textContent") {
-              expectedValue = await relElem.evaluate((el) => el.textContent ?? void 0);
-            } else {
-              const attr = await relElem.getAttribute(prop);
-              expectedValue = attr === null ? void 0 : attr;
-            }
-          } else {
-            expectedValue = await resolveExpectedValue(assertion.expectedValue, componentContract.selectors, page, {});
-          }
-        } else if (typeof assertion.expectedValue === "string" || typeof assertion.expectedValue === "undefined") {
-          expectedValue = assertion.expectedValue;
-        } else {
-          expectedValue = "";
-        }
-        const assertionToRun = { ...assertion, expectedValue };
-        const valueToCheck = expectedValue ?? "";
-        const result = await assertionRunner.validate({ ...assertionToRun, expectedValue: valueToCheck }, dynamicTest.description);
-        if (result.success && result.passMessage) {
-          passes.push(result.passMessage);
-        } else if (!result.success && result.failMessage) {
-          const assertionLevel = normalizeLevel(assertion.level || dynamicTest.level);
-          const outcome = classifyFailure(result.failMessage, assertionLevel);
-          if (outcome.status === "skip") {
-            continue;
-          }
-        }
-      }
-      const failuresAfterTest = failures.length;
-      const warningsAfterTest = warnings.length;
-      const skippedAfterTest = skipped.length;
-      if (failuresAfterTest > failuresBeforeTest) {
-        reporter.reportTest(
-          { description: dynamicTest.description, level: dynamicLevel },
-          "fail",
-          failures[failures.length - 1]
-        );
-      } else if (warningsAfterTest > warningsBeforeTest) {
-        reporter.reportTest(
-          { description: dynamicTest.description, level: dynamicLevel },
-          "warn",
-          warnings[warnings.length - 1]
-        );
-      } else if (skippedAfterTest > skippedBeforeTest) {
-        reporter.reportTest(
-          { description: dynamicTest.description, level: dynamicLevel },
-          "skip",
-          skipped[skipped.length - 1]
-        );
-      } else {
-        reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "pass");
-      }
-    }
-    reporter.reportStatic(staticPassed, staticFailed, staticWarnings);
-    reporter.summary(failures);
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Executable doesn't exist") || error.message.includes("browserType.launch")) {
-        throw new Error("\n\u274C CRITICAL: Playwright browsers not found!\n\u{1F4E6} Run: npx playwright install chromium");
-      } else if (error.message.includes("net::ERR_CONNECTION_REFUSED") || error.message.includes("NS_ERROR_CONNECTION_REFUSED")) {
-        throw new Error(`
-\u274C CRITICAL: Cannot connect to dev server!
-Make sure your dev server is running at ${url}`);
-      } else if (error.message.includes("Timeout") && error.message.includes("waitFor")) {
-        throw new Error(
-          `
-\u274C CRITICAL: Component not found on page!
-The component selector could not be found within ${componentReadyTimeoutMs}ms.
-This usually means:
-  - The component didn't render
-  - The URL is incorrect
-  - The component selector was not provided to the component utility, or a wrong selector was used
-`
-        );
-      } else if (error.message.includes("Target page, context or browser has been closed")) {
-        throw new Error(
-          "\n\u274C CRITICAL: Browser/page was closed unexpectedly!\nThis usually means:\n  - The test timeout was too short\n  - The browser crashed\n  - An external process killed the browser"
-        );
-      } else {
-        throw error;
-      }
-    }
-  } finally {
-    if (page) await page.close();
-  }
-  return { passes, failures, skipped, warnings };
-}
-
-export { runContractTestsPlaywright };