aria-ease 6.4.7 → 6.4.10

package/bin/contractTestRunnerPlaywright-D57V4RSU.js

@@ -1,628 +0,0 @@
-import {
-  ContractReporter,
-  contract_default,
-  createTestPage
-} from "./chunk-TQBS54MM.js";
-import {
-  __export,
-  __reExport
-} from "./chunk-I2KLQ2HA.js";
-
-// node_modules/@playwright/test/index.mjs
-var test_exports = {};
-__export(test_exports, {
-  default: () => default2
-});
-__reExport(test_exports, test_star);
-import * as test_star from "playwright/test";
-import { default as default2 } from "playwright/test";
-
-// src/utils/test/contract/contractTestRunnerPlaywright.ts
-import { readFileSync } from "fs";
-async function runContractTestsPlaywright(componentName, url) {
-  const reporter = new ContractReporter(true);
-  const actionTimeoutMs = 400;
-  const assertionTimeoutMs = 400;
-  function isBrowserClosedError(error) {
-    return error instanceof Error && error.message.includes("Target page, context or browser has been closed");
-  }
-  const contractTyped = contract_default;
-  const contractPath = contractTyped[componentName]?.path;
-  if (!contractPath) {
-    throw new Error(`Contract path not found for component: ${componentName}`);
-  }
-  const resolvedPath = new URL(contractPath, import.meta.url).pathname;
-  const contractData = readFileSync(resolvedPath, "utf-8");
-  const componentContract = JSON.parse(contractData);
-  const totalTests = componentContract.static[0].assertions.length + componentContract.dynamic.length;
-  const apgUrl = componentContract.meta?.source?.apg;
-  reporter.start(componentName, totalTests, apgUrl);
-  const failures = [];
-  const passes = [];
-  const skipped = [];
-  let page = null;
-  try {
-    page = await createTestPage();
-    if (url) {
-      try {
-        await page.goto(url, {
-          waitUntil: "domcontentloaded",
-          timeout: 3e4
-        });
-      } 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 mainSelector = componentContract.selectors.trigger || componentContract.selectors.input || componentContract.selectors.container || componentContract.selectors.tablist || componentContract.selectors.tab;
-    if (!mainSelector) {
-      throw new Error(`CRITICAL: No main selector (trigger, input, container, tablist, or tab) found in contract for ${componentName}`);
-    }
-    try {
-      await page.locator(mainSelector).first().waitFor({ state: "attached", timeout: 3e4 });
-    } catch (error) {
-      throw new Error(
-        `CRITICAL: Component element '${mainSelector}' not found on page within 30s. This usually means the component didn't render or the contract selector is incorrect. Original error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (componentName === "menu" && componentContract.selectors.trigger) {
-      await page.locator(componentContract.selectors.trigger).first().waitFor({
-        state: "visible",
-        timeout: 5e3
-      }).catch(() => {
-        console.warn("Menu trigger not visible, continuing with tests...");
-      });
-    }
-    async function resolveRelativeTarget(selector, relative) {
-      if (!page) {
-        throw new Error("Page is not initialized");
-      }
-      const items = await page.locator(selector).all();
-      switch (relative) {
-        case "first":
-          return items[0];
-        case "second":
-          return items[1];
-        case "last":
-          return items[items.length - 1];
-        case "next": {
-          const currentIndex = await page.evaluate(([sel]) => {
-            const items2 = Array.from(document.querySelectorAll(sel));
-            return items2.indexOf(document.activeElement);
-          }, [selector]);
-          const nextIndex = (currentIndex + 1) % items.length;
-          return items[nextIndex];
-        }
-        case "previous": {
-          const currentIndex = await page.evaluate(([sel]) => {
-            const items2 = Array.from(document.querySelectorAll(sel));
-            return items2.indexOf(document.activeElement);
-          }, [selector]);
-          const prevIndex = (currentIndex - 1 + items.length) % items.length;
-          return items[prevIndex];
-        }
-        default:
-          return null;
-      }
-    }
-    for (const test of componentContract.static[0]?.assertions || []) {
-      if (test.target === "relative") continue;
-      const targetSelector = componentContract.selectors[test.target];
-      if (!targetSelector) {
-        failures.push(`Selector for target ${test.target} not found.`);
-        continue;
-      }
-      const target = page.locator(targetSelector).first();
-      const exists = await target.count() > 0;
-      if (!exists) {
-        failures.push(`Target ${test.target} not found.`);
-        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;
-      };
-      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) {
-          failures.push(test.failureMessage + ` None of the attributes "${test.attribute}" are present.`);
-        } else if (!allRedundant && hasAny) {
-          passes.push(`At least one of the attributes "${test.attribute}" exists on the element.`);
-        }
-      } else {
-        if (isRedundantCheck(targetSelector, test.attribute, test.expectedValue)) {
-          passes.push(`${test.attribute}="${test.expectedValue}" on ${test.target} verified by selector (already present in: ${targetSelector}).`);
-        } else {
-          const attributeValue = await target.getAttribute(test.attribute);
-          const expectedValues = test.expectedValue.split(" | ");
-          if (!attributeValue || !expectedValues.includes(attributeValue)) {
-            failures.push(test.failureMessage + ` Attribute value does not match expected value. Expected: ${test.expectedValue}, Found: ${attributeValue}`);
-          } else {
-            passes.push(`Attribute value matches expected value. Expected: ${test.expectedValue}, Found: ${attributeValue}`);
-          }
-        }
-      }
-    }
-    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;
-      }
-      const { action, assertions } = dynamicTest;
-      const failuresBeforeTest = failures.length;
-      if (componentContract.selectors.popup) {
-        const popupSelector = componentContract.selectors.popup;
-        if (!popupSelector) continue;
-        const popupElement = page.locator(popupSelector).first();
-        const isPopupVisible = await popupElement.isVisible().catch(() => false);
-        if (isPopupVisible) {
-          let menuClosed = false;
-          let closeSelector = componentContract.selectors.input;
-          if (!closeSelector && componentContract.selectors.focusable) {
-            closeSelector = componentContract.selectors.focusable;
-          } else if (!closeSelector) {
-            closeSelector = componentContract.selectors.trigger;
-          }
-          if (closeSelector) {
-            const closeElement = page.locator(closeSelector).first();
-            await closeElement.focus();
-            await page.keyboard.press("Escape");
-            menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: assertionTimeoutMs }).then(() => true).catch(() => false);
-          }
-          if (!menuClosed && componentContract.selectors.trigger) {
-            const triggerElement = page.locator(componentContract.selectors.trigger).first();
-            await triggerElement.click({ timeout: actionTimeoutMs });
-            menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: assertionTimeoutMs }).then(() => true).catch(() => false);
-          }
-          if (!menuClosed) {
-            await page.mouse.click(10, 10);
-            menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: assertionTimeoutMs }).then(() => true).catch(() => false);
-          }
-          if (!menuClosed) {
-            throw new Error(
-              `\u274C FATAL: Cannot close menu between tests. Menu remains visible after trying:
-  1. Escape key
-  2. Clicking trigger
-  3. Clicking outside
-This indicates a problem with the menu component's close functionality.`
-            );
-          }
-          if (componentContract.selectors.input) {
-            await page.locator(componentContract.selectors.input).first().clear();
-          }
-          if (componentName === "menu" && componentContract.selectors.trigger) {
-            const triggerElement = page.locator(componentContract.selectors.trigger).first();
-            await triggerElement.focus();
-          }
-        }
-      }
-      if (componentContract.selectors.panel && componentContract.selectors.trigger && !componentContract.selectors.popup) {
-        const triggerSelector = componentContract.selectors.trigger;
-        const panelSelector = componentContract.selectors.panel;
-        if (triggerSelector && panelSelector) {
-          const allTriggers = await page.locator(triggerSelector).all();
-          for (const trigger of allTriggers) {
-            const isExpanded = await trigger.getAttribute("aria-expanded") === "true";
-            const triggerPanel = await trigger.getAttribute("aria-controls");
-            if (isExpanded && triggerPanel) {
-              await trigger.click({ timeout: actionTimeoutMs });
-              const panel = page.locator(`#${triggerPanel}`);
-              await (0, test_exports.expect)(panel).toBeHidden({ timeout: assertionTimeoutMs }).catch(() => {
-              });
-            }
-          }
-        }
-      }
-      let shouldSkipTest = false;
-      for (const act of action) {
-        if (act.type === "keypress" && (act.target === "submenuTrigger" || act.target === "submenu")) {
-          const submenuSelector = componentContract.selectors[act.target];
-          if (submenuSelector) {
-            const submenuCount = await page.locator(submenuSelector).count();
-            if (submenuCount === 0) {
-              reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
-              shouldSkipTest = true;
-              break;
-            }
-          }
-        }
-      }
-      if (!shouldSkipTest) {
-        for (const assertion of assertions) {
-          if (assertion.target === "submenu" || assertion.target === "submenuTrigger") {
-            const submenuSelector = componentContract.selectors[assertion.target];
-            if (submenuSelector) {
-              const submenuCount = await page.locator(submenuSelector).count();
-              if (submenuCount === 0) {
-                reporter.reportTest(dynamicTest, "skip", `Skipping test - ${assertion.target} element not found (optional submenu test)`);
-                shouldSkipTest = true;
-                break;
-              }
-            }
-          }
-        }
-      }
-      if (shouldSkipTest) {
-        continue;
-      }
-      if (componentContract.selectors.panel && componentContract.selectors.tab && componentContract.selectors.tablist) {
-        if (dynamicTest.isVertical !== void 0 && componentContract.selectors.tablist) {
-          const tablistSelector = componentContract.selectors.tablist;
-          const tablist = page.locator(tablistSelector).first();
-          const orientation = await tablist.getAttribute("aria-orientation");
-          const isVertical = orientation === "vertical";
-          if (dynamicTest.isVertical !== isVertical) {
-            const skipReason = dynamicTest.isVertical ? `Skipping vertical tabs test - component has horizontal orientation` : `Skipping horizontal tabs test - component has vertical orientation`;
-            reporter.reportTest(dynamicTest, "skip", skipReason);
-            continue;
-          }
-        }
-      }
-      for (const act of action) {
-        if (!page || page.isClosed()) {
-          failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-          break;
-        }
-        if (act.type === "focus") {
-          try {
-            const focusSelector = componentContract.selectors[act.target];
-            if (!focusSelector) {
-              failures.push(`Selector for focus target ${act.target} not found.`);
-              continue;
-            }
-            await page.locator(focusSelector).first().focus({ timeout: actionTimeoutMs });
-          } catch (error) {
-            if (isBrowserClosedError(error)) {
-              failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-              break;
-            }
-            failures.push(`Failed to focus ${act.target}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-          }
-        }
-        if (act.type === "type" && act.value) {
-          try {
-            const typeSelector = componentContract.selectors[act.target];
-            if (!typeSelector) {
-              failures.push(`Selector for type target ${act.target} not found.`);
-              continue;
-            }
-            await page.locator(typeSelector).first().fill(act.value, { timeout: actionTimeoutMs });
-          } catch (error) {
-            if (isBrowserClosedError(error)) {
-              failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-              break;
-            }
-            failures.push(`Failed to type into ${act.target}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-          }
-        }
-        if (act.type === "click") {
-          try {
-            if (act.target === "document") {
-              await page.mouse.click(10, 10);
-            } else if (act.target === "relative" && act.relativeTarget) {
-              const relativeSelector = componentContract.selectors.relative;
-              if (!relativeSelector) {
-                failures.push(`Relative selector not defined for click action.`);
-                continue;
-              }
-              const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
-              if (!relativeElement) {
-                failures.push(`Could not resolve relative target ${act.relativeTarget} for click.`);
-                continue;
-              }
-              await relativeElement.click({ timeout: actionTimeoutMs });
-            } else {
-              const actionSelector = componentContract.selectors[act.target];
-              if (!actionSelector) {
-                failures.push(`Selector for action target ${act.target} not found.`);
-                continue;
-              }
-              await page.locator(actionSelector).first().click({ timeout: actionTimeoutMs });
-            }
-          } catch (error) {
-            if (isBrowserClosedError(error)) {
-              failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-              break;
-            }
-            failures.push(`Failed to click ${act.target}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-          }
-        }
-        if (act.type === "keypress" && act.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[act.key] || act.key;
-            if (keyValue === "Space") {
-              keyValue = " ";
-            } else if (keyValue.includes(" ")) {
-              keyValue = keyValue.replace(/ /g, "");
-            }
-            if (act.target === "focusable" && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Escape"].includes(keyValue)) {
-              await page.keyboard.press(keyValue);
-            } else {
-              const keypressSelector = componentContract.selectors[act.target];
-              if (!keypressSelector) {
-                failures.push(`Selector for keypress target ${act.target} not found.`);
-                continue;
-              }
-              const target = page.locator(keypressSelector).first();
-              const elementCount = await target.count();
-              if (elementCount === 0) {
-                reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
-                break;
-              }
-              await target.press(keyValue, { timeout: actionTimeoutMs });
-            }
-          } catch (error) {
-            if (isBrowserClosedError(error)) {
-              failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-              break;
-            }
-            failures.push(`Failed to press ${act.key} on ${act.target}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-          }
-        }
-        if (act.type === "hover") {
-          try {
-            if (act.target === "relative" && act.relativeTarget) {
-              const relativeSelector = componentContract.selectors.relative;
-              if (!relativeSelector) {
-                failures.push(`Relative selector not defined for hover action.`);
-                continue;
-              }
-              const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
-              if (!relativeElement) {
-                failures.push(`Could not resolve relative target ${act.relativeTarget} for hover.`);
-                continue;
-              }
-              await relativeElement.hover({ timeout: actionTimeoutMs });
-            } else {
-              const hoverSelector = componentContract.selectors[act.target];
-              if (!hoverSelector) {
-                failures.push(`Selector for hover target ${act.target} not found.`);
-                continue;
-              }
-              await page.locator(hoverSelector).first().hover({ timeout: actionTimeoutMs });
-            }
-          } catch (error) {
-            if (isBrowserClosedError(error)) {
-              failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
-              break;
-            }
-            failures.push(`Failed to hover ${act.target}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-          }
-        }
-      }
-      for (const assertion of assertions) {
-        if (!page || page.isClosed()) {
-          failures.push(`CRITICAL: Browser/page closed before completing all tests. Increase test timeout or reduce test complexity.`);
-          break;
-        }
-        let target;
-        try {
-          if (assertion.target === "relative") {
-            const relativeSelector = componentContract.selectors.relative;
-            if (!relativeSelector) {
-              failures.push("Relative selector is not defined in the contract.");
-              continue;
-            }
-            const relativeTargetValue = assertion.relativeTarget || assertion.expectedValue;
-            if (!relativeTargetValue) {
-              failures.push("Relative target or expected value is not defined.");
-              continue;
-            }
-            target = await resolveRelativeTarget(relativeSelector, relativeTargetValue);
-          } else {
-            const assertionSelector = componentContract.selectors[assertion.target];
-            if (!assertionSelector) {
-              failures.push(`Selector for assertion target ${assertion.target} not found.`);
-              continue;
-            }
-            target = page.locator(assertionSelector).first();
-          }
-          if (!target) {
-            failures.push(`Target ${assertion.target} not found.`);
-            continue;
-          }
-        } catch (error) {
-          failures.push(`Failed to resolve target ${assertion.target}: ${error instanceof Error ? error.message : String(error)}`);
-          continue;
-        }
-        if (assertion.assertion === "toBeVisible") {
-          try {
-            await (0, test_exports.expect)(target).toBeVisible({ timeout: assertionTimeoutMs });
-            passes.push(`${assertion.target} is visible as expected. Test: "${dynamicTest.description}".`);
-          } catch {
-            const debugState = await 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}`;
-            }, componentContract.selectors[assertion.target] || "");
-            failures.push(`${assertion.failureMessage} (actual: ${debugState})`);
-          }
-        }
-        if (assertion.assertion === "notToBeVisible") {
-          try {
-            await (0, test_exports.expect)(target).toBeHidden({ timeout: assertionTimeoutMs });
-            passes.push(`${assertion.target} is not visible as expected. Test: "${dynamicTest.description}".`);
-          } catch {
-            const debugState = await 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}`;
-            }, componentContract.selectors[assertion.target] || "");
-            failures.push(assertion.failureMessage + ` ${assertion.target} is still visible (actual: ${debugState}).`);
-          }
-        }
-        if (assertion.assertion === "toHaveAttribute" && assertion.attribute && assertion.expectedValue) {
-          try {
-            if (assertion.expectedValue === "!empty") {
-              const attributeValue = await target.getAttribute(assertion.attribute);
-              if (attributeValue && attributeValue.trim() !== "") {
-                passes.push(`${assertion.target} has non-empty "${assertion.attribute}". Test: "${dynamicTest.description}".`);
-              } else {
-                failures.push(assertion.failureMessage + ` ${assertion.target} "${assertion.attribute}" should not be empty, found "${attributeValue}".`);
-              }
-            } else {
-              await (0, test_exports.expect)(target).toHaveAttribute(assertion.attribute, assertion.expectedValue, { timeout: assertionTimeoutMs });
-              passes.push(`${assertion.target} has expected "${assertion.attribute}". Test: "${dynamicTest.description}".`);
-            }
-          } catch {
-            const attributeValue = await target.getAttribute(assertion.attribute);
-            failures.push(assertion.failureMessage + ` ${assertion.target} "${assertion.attribute}" should be "${assertion.expectedValue}", found "${attributeValue}".`);
-          }
-        }
-        if (assertion.assertion === "toHaveValue") {
-          const inputValue = await target.inputValue().catch(() => "");
-          if (assertion.expectedValue === "!empty") {
-            if (inputValue && inputValue.trim() !== "") {
-              passes.push(`${assertion.target} has non-empty value. Test: "${dynamicTest.description}".`);
-            } else {
-              failures.push(assertion.failureMessage + ` ${assertion.target} value should not be empty, found "${inputValue}".`);
-            }
-          } else if (assertion.expectedValue === "") {
-            if (inputValue === "") {
-              passes.push(`${assertion.target} has empty value. Test: "${dynamicTest.description}".`);
-            } else {
-              failures.push(assertion.failureMessage + ` ${assertion.target} value should be empty, found "${inputValue}".`);
-            }
-          } else if (inputValue === assertion.expectedValue) {
-            passes.push(`${assertion.target} has expected value. Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(assertion.failureMessage + ` ${assertion.target} value should be "${assertion.expectedValue}", found "${inputValue}".`);
-          }
-        }
-        if (assertion.assertion === "toHaveFocus") {
-          try {
-            await (0, test_exports.expect)(target).toBeFocused({ timeout: assertionTimeoutMs });
-            passes.push(`${assertion.target} has focus as expected. Test: "${dynamicTest.description}".`);
-          } catch {
-            const actualFocus = await page.evaluate(() => {
-              const focused = document.activeElement;
-              return focused ? `${focused.tagName}#${focused.id || "no-id"}.${focused.className || "no-class"}` : "no element focused";
-            });
-            failures.push(`${assertion.failureMessage} (actual focus: ${actualFocus})`);
-          }
-        }
-        if (assertion.assertion === "toHaveRole" && assertion.expectedValue) {
-          const roleValue = await target.getAttribute("role");
-          if (roleValue === assertion.expectedValue) {
-            passes.push(`${assertion.target} has role "${assertion.expectedValue}". Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(assertion.failureMessage + ` Expected role "${assertion.expectedValue}", found "${roleValue}".`);
-          }
-        }
-      }
-      const failuresAfterTest = failures.length;
-      const testPassed = failuresAfterTest === failuresBeforeTest;
-      const failureMessage = testPassed ? void 0 : failures[failures.length - 1];
-      if (dynamicTest.isOptional === true && !testPassed) {
-        failures.pop();
-        reporter.reportTest(dynamicTest, "optional-fail", failureMessage);
-      } else {
-        reporter.reportTest(dynamicTest, testPassed ? "pass" : "fail", failureMessage);
-      }
-    }
-    const staticPassed = componentContract.static[0].assertions.length;
-    const staticFailed = 0;
-    reporter.reportStatic(staticPassed, staticFailed);
-    reporter.summary(failures);
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Executable doesn't exist") || error.message.includes("browserType.launch")) {
-        console.error("\n\u274C CRITICAL: Playwright browsers not found!\n");
-        console.log("\u{1F4E6} Run: npx playwright install chromium\n");
-        failures.push("CRITICAL: Playwright browser not installed. Run: npx playwright install chromium");
-      } else if (error.message.includes("net::ERR_CONNECTION_REFUSED") || error.message.includes("NS_ERROR_CONNECTION_REFUSED")) {
-        console.error("\n\u274C CRITICAL: Cannot connect to dev server!\n");
-        console.log(`   Make sure your dev server is running at ${url}
-`);
-        failures.push(`CRITICAL: Dev server not running at ${url}`);
-      } else if (error.message.includes("Timeout") && error.message.includes("waitFor")) {
-        console.error("\n\u274C CRITICAL: Component not found on page!\n");
-        console.log(`   The component selector could not be found within 30 seconds.
-`);
-        console.log(`   This usually means:
-`);
-        console.log(`   - The component didn't render
-`);
-        console.log(`   - The URL is incorrect
-`);
-        console.log(`   - The component selector in the contract is wrong
-`);
-        failures.push(`CRITICAL: Component element not found on page - ${error.message}`);
-      } else if (error.message.includes("Target page, context or browser has been closed")) {
-        console.error("\n\u274C CRITICAL: Browser/page was closed unexpectedly!\n");
-        console.log(`   This usually means:
-`);
-        console.log(`   - The test timeout was too short
-`);
-        console.log(`   - The browser crashed
-`);
-        console.log(`   - An external process killed the browser
-`);
-        failures.push(`CRITICAL: Browser/page closed unexpectedly - ${error.message}`);
-      } else if (error.message.includes("FATAL")) {
-        console.error(`
-${error.message}
-`);
-        failures.push(error.message);
-      } else {
-        console.error("\n\u274C UNEXPECTED ERROR:", error.message);
-        console.error("Stack:", error.stack);
-        failures.push(`UNEXPECTED ERROR: ${error.message}`);
-      }
-    }
-  } finally {
-    if (page) await page.close();
-  }
-  return { passes, failures, skipped };
-}
-export {
-  runContractTestsPlaywright
-};