aria-ease 6.9.0 → 6.10.0

package/dist/src/utils/test/dsl/index.js

@@ -0,0 +1,311 @@
+// src/utils/test/dsl/src/state-packs/comboboxStatePack.ts
+var COMBOBOX_STATES = {
+  "listbox.open": {
+    setup: openCombobox(),
+    assertion: isComboboxOpen()
+  },
+  "listbox.closed": {
+    setup: closeCombobox(),
+    assertion: isComboboxClosed()
+  },
+  "input.focused": {
+    setup: focusInput(),
+    assertion: [
+      ...isInputFocused()
+    ]
+  },
+  "input.filled": {
+    setup: fillInput(),
+    assertion: [
+      ...isInputFilled()
+    ]
+  },
+  "activeOption.first": {
+    requires: ["listbox.open"],
+    setup: [
+      { type: "keypress", target: "input", key: "ArrowDown" }
+    ],
+    assertion: [
+      ...isActiveDescendantNotEmpty()
+    ]
+  },
+  "activeOption.last": {
+    requires: ["activeOption.first"],
+    setup: [
+      { type: "keypress", target: "input", key: "ArrowUp" }
+    ],
+    assertion: [
+      ...isActiveDescendantNotEmpty()
+    ]
+  },
+  "selectedOption.first": {
+    requires: ["listbox.open"],
+    setup: [
+      { type: "click", target: "relative", relativeTarget: "first" }
+    ],
+    assertion: [
+      ...isAriaSelected("first")
+    ]
+  },
+  "selectedOption.last": {
+    requires: ["listbox.open"],
+    setup: [
+      { type: "click", target: "relative", relativeTarget: "last" }
+    ],
+    assertion: [
+      ...isAriaSelected("first")
+    ]
+  }
+};
+function openCombobox() {
+  return [
+    { type: "keypress", target: "input", key: "ArrowDown" }
+  ];
+}
+function closeCombobox() {
+  return [
+    { type: "keypress", target: "input", key: "Escape" }
+  ];
+}
+function focusInput() {
+  return [
+    { type: "focus", target: "input" }
+  ];
+}
+function fillInput() {
+  return [
+    { type: "type", target: "input", value: "test" }
+  ];
+}
+function isComboboxOpen() {
+  return [
+    {
+      target: "listbox",
+      assertion: "toBeVisible",
+      failureMessage: "Expected listbox to be visible"
+    }
+  ];
+}
+function isComboboxClosed() {
+  return [
+    {
+      target: "listbox",
+      assertion: "notToBeVisible",
+      failureMessage: "Expected listbox to be closed"
+    }
+  ];
+}
+function isActiveDescendantNotEmpty() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveAttribute",
+      attribute: "aria-activedescendant",
+      expectedValue: "!empty",
+      failureMessage: "Expected aria-activedescendant to not be empty"
+    }
+  ];
+}
+function isAriaSelected(index) {
+  return [
+    {
+      target: "relative",
+      relativeTarget: index,
+      assertion: "toHaveAttribute",
+      attribute: "aria-selected",
+      expectedValue: "true",
+      failureMessage: `Expected aria-selected on ${index} option to be true`
+    }
+  ];
+}
+function isInputFocused() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveFocus",
+      failureMessage: "Expected input to be focused"
+    }
+  ];
+}
+function isInputFilled() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveValue",
+      expectedValue: "test",
+      failureMessage: "Expected input to have the value 'test'"
+    }
+  ];
+}
+
+// src/utils/test/dsl/src/contractBuilder.ts
+var STATE_PACKS = {
+  "combobox.listbox": COMBOBOX_STATES
+  // Add more mappings as needed
+};
+var FluentContract = class {
+  constructor(jsonContract) {
+    this.jsonContract = jsonContract;
+  }
+  toJSON() {
+    return this.jsonContract;
+  }
+};
+var ContractBuilder = class {
+  constructor(componentName) {
+    this.componentName = componentName;
+    this.statePack = STATE_PACKS[componentName] || {};
+  }
+  metaValue = {};
+  selectorsValue = {};
+  relationshipInvariants = [];
+  staticAssertions = [];
+  dynamicTests = [];
+  statePack;
+  meta(meta) {
+    this.metaValue = meta;
+    return this;
+  }
+  selectors(selectors) {
+    this.selectorsValue = selectors;
+    return this;
+  }
+  relationships(fn) {
+    const api = {
+      ariaReference: (from, attribute, to) => ({
+        required: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "required" }),
+        optional: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "optional" })
+      }),
+      contains: (parent, child) => ({
+        required: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "required" }),
+        optional: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "optional" })
+      })
+    };
+    fn(api);
+    return this;
+  }
+  static(fn) {
+    const api = {
+      target: (target) => ({
+        has: (attribute, expectedValue) => ({
+          required: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "required" }),
+          optional: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "optional" })
+        })
+      })
+    };
+    fn(api);
+    return this;
+  }
+  when(event) {
+    return new DynamicTestBuilder(this, this.statePack, event);
+  }
+  addDynamicTest(test) {
+    this.dynamicTests.push(test);
+  }
+  build() {
+    return {
+      meta: this.metaValue,
+      selectors: this.selectorsValue,
+      relationships: this.relationshipInvariants.length ? this.relationshipInvariants : void 0,
+      static: this.staticAssertions.length ? [{ assertions: this.staticAssertions }] : [],
+      dynamic: this.dynamicTests
+    };
+  }
+};
+var DynamicTestBuilder = class {
+  constructor(parent, statePack, event) {
+    this.parent = parent;
+    this.statePack = statePack;
+    this.event = event;
+  }
+  _as;
+  _on;
+  _given = [];
+  _then = [];
+  _desc = "";
+  _level = "required";
+  as(actionType) {
+    this._as = actionType;
+    return this;
+  }
+  on(target) {
+    this._on = target;
+    return this;
+  }
+  given(states) {
+    this._given = Array.isArray(states) ? states : [states];
+    return this;
+  }
+  then(states) {
+    this._then = Array.isArray(states) ? states : [states];
+    return this;
+  }
+  describe(desc) {
+    this._desc = desc;
+    return this;
+  }
+  required() {
+    this._level = "required";
+    this._finalize();
+    return this.parent;
+  }
+  optional() {
+    this._level = "optional";
+    this._finalize();
+    return this.parent;
+  }
+  recommended() {
+    this._level = "recommended";
+    this._finalize();
+    return this.parent;
+  }
+  _finalize() {
+    const resolveSetup = (stateName, visited = /* @__PURE__ */ new Set()) => {
+      if (visited.has(stateName)) return [];
+      visited.add(stateName);
+      const s = this.statePack[stateName];
+      if (!s) return [];
+      let actions = [];
+      if (Array.isArray(s.requires)) {
+        for (const req of s.requires) {
+          actions = actions.concat(resolveSetup(req, visited));
+        }
+      }
+      if (s.setup) actions = actions.concat(s.setup);
+      return actions;
+    };
+    const setup = [];
+    for (const state of this._given) {
+      setup.push(...resolveSetup(state));
+    }
+    const assertions = [];
+    for (const state of this._then) {
+      const s = this.statePack[state];
+      if (s && s.assertion) {
+        if (Array.isArray(s.assertion)) assertions.push(...s.assertion);
+        else assertions.push(s.assertion);
+      }
+    }
+    const action = [
+      {
+        type: this._as,
+        target: this._on,
+        key: this._as === "keypress" ? this.event : void 0
+      }
+    ];
+    this.parent.addDynamicTest({
+      description: this._desc || "",
+      level: this._level,
+      action,
+      assertions,
+      ...setup.length ? { setup } : {}
+    });
+  }
+};
+function createContract(componentName, define) {
+  const builder = new ContractBuilder(componentName);
+  define(builder);
+  return new FluentContract(builder.build());
+}
+
+export { createContract };

package/dist/src/utils/test/index.cjs

@@ -445,6 +445,23 @@ function validateConfig(config) {
     if (typeof cfg.test !== "object" || cfg.test === null) {
       errors.push("test must be an object");
     } else {
+      if (cfg.test.disableTimeouts !== void 0 && typeof cfg.test.disableTimeouts !== "boolean") {
+        errors.push("test.disableTimeouts must be a boolean when provided");
+      }
+      const testTimeoutFields = [
+        "actionTimeoutMs",
+        "assertionTimeoutMs",
+        "navigationTimeoutMs",
+        "componentReadyTimeoutMs"
+      ];
+      for (const field of testTimeoutFields) {
+        const value = cfg.test[field];
+        if (value !== void 0) {
+          if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+            errors.push(`test.${field} must be a non-negative number when provided`);
+          }
+        }
+      }
       if (cfg.test.components !== void 0) {
         if (!Array.isArray(cfg.test.components)) {
           errors.push("test.components must be an array");
@@ -465,6 +482,23 @@ function validateConfig(config) {
               if (comp.strictness !== void 0 && !["minimal", "balanced", "strict", "paranoid"].includes(comp.strictness)) {
                 errors.push(`test.components[${idx}].strictness must be one of: minimal, balanced, strict, paranoid`);
               }
+              if (comp.disableTimeouts !== void 0 && typeof comp.disableTimeouts !== "boolean") {
+                errors.push(`test.components[${idx}].disableTimeouts must be a boolean when provided`);
+              }
+              const componentTimeoutFields = [
+                "actionTimeoutMs",
+                "assertionTimeoutMs",
+                "navigationTimeoutMs",
+                "componentReadyTimeoutMs"
+              ];
+              for (const field of componentTimeoutFields) {
+                const value = comp[field];
+                if (value !== void 0) {
+                  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+                    errors.push(`test.components[${idx}].${field} must be a non-negative number when provided`);
+                  }
+                }
+              }
             }
           });
         }
@@ -1005,8 +1039,41 @@ var init_ActionExecutor = __esm({
       /**
        * Execute focus action
        */
-      async focus(target) {
+      /**
+       * 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 inputSelector = this.selectors.input;
+            if (!inputSelector) {
+              return { success: false, error: `Input selector not defined for virtual focus.` };
+            }
+            const input = this.page.locator(inputSelector).first();
+            const exists = await input.count();
+            if (!exists) {
+              return { success: false, error: `Input element not found for virtual focus.` };
+            }
+            await input.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.` };
@@ -1203,10 +1270,10 @@ var init_AssertionRunner = __esm({
       /**
        * Resolve the target element for an assertion
        */
-      async resolveTarget(targetName, relativeTarget) {
+      async resolveTarget(targetName, relativeTarget, selectorKey) {
         try {
           if (targetName === "relative") {
-            const relativeSelector = this.selectors.relative;
+            const relativeSelector = selectorKey ? this.selectors[selectorKey] : this.selectors.relative;
             if (!relativeSelector) {
               return { target: null, error: "Relative selector is not defined in the contract." };
             }
@@ -1393,10 +1460,30 @@ var init_AssertionRunner = __esm({
             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);
+        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);
@@ -1443,8 +1530,43 @@ async function runContractTestsPlaywright(componentName, url, strictness, config
   const componentConfig = config?.test?.components?.find((c) => c.name === componentName);
   const isCustomContract = !!componentConfig?.path;
   const reporter = new ContractReporter(true, isCustomContract);
-  const actionTimeoutMs = 400;
-  const assertionTimeoutMs = 400;
+  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);
   let contractPath = componentConfig?.path;
   if (!contractPath) {
@@ -1502,7 +1624,7 @@ async function runContractTestsPlaywright(componentName, url, strictness, config
       try {
         await page.goto(url, {
           waitUntil: "domcontentloaded",
-          timeout: 3e4
+          timeout: navigationTimeoutMs
         });
       } catch (error) {
         throw new Error(
@@ -1520,7 +1642,7 @@ async function runContractTestsPlaywright(componentName, url, strictness, config
       throw new Error(`CRITICAL: No selector found in contract for ${componentName}`);
     }
     try {
-      await page.locator(mainSelector).first().waitFor({ state: "attached", timeout: 3e4 });
+      await page.locator(mainSelector).first().waitFor({ state: "attached", timeout: componentReadyTimeoutMs });
     } catch (error) {
       throw new Error(
         `
@@ -1534,18 +1656,26 @@ This usually means:
     }
     reporter.start(componentName, totalTests, apgUrl);
     if (componentName === "menu" && componentContract.selectors.trigger) {
-      await page.locator(componentContract.selectors.trigger).first().waitFor({
-        state: "attached",
-        timeout: 5e3
-      }).catch(() => {
+      await page.locator(componentContract.selectors.trigger).first().waitFor({ state: "attached", 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 || []) {
       const relationshipLevel = normalizeLevel(rel.level);
+      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];
@@ -1565,6 +1695,12 @@ This usually means:
         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
@@ -1620,6 +1756,12 @@ This usually means:
         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;
@@ -1629,6 +1771,12 @@ This usually means:
         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
@@ -1752,11 +1900,6 @@ This usually means:
         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;
-      const warningsBeforeTest = warnings.length;
-      const skippedBeforeTest = skipped.length;
-      const dynamicLevel = normalizeLevel(dynamicTest.level);
       try {
         await strategy.resetState(page);
       } catch (error) {
@@ -1764,6 +1907,40 @@ This usually means:
         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) {
+        for (const setupAct of setup) {
+          let setupResult;
+          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;
+          }
+          if (!setupResult.success) {
+            const setupMsg = setupResult.error || "Setup action failed";
+            const outcome = classifyFailure(`Setup failed: ${setupMsg}`, 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`;
@@ -1771,7 +1948,6 @@ This usually means:
         reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "skip", skipMessage);
         continue;
       }
-      const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
       const assertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
       let shouldAbortCurrentTest = false;
       let actionOutcome = null;
@@ -1783,7 +1959,11 @@ This usually means:
         }
         let result;
         if (act.type === "focus") {
-          result = await actionExecutor.focus(act.target);
+          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") {
@@ -1861,7 +2041,14 @@ This usually means:
 Make sure your dev server is running at ${url}`);
       } else if (error.message.includes("Timeout") && error.message.includes("waitFor")) {
         throw new Error(
-          "\n\u274C CRITICAL: Component not found on page!\nThe component selector could not be found within 30 seconds.\nThis usually means:\n  - The component didn't render\n  - The URL is incorrect\n  - The component selector was not provided to the component utility, or a wrong selector was used\n"
+          `
+\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(

package/dist/src/utils/test/index.js

@@ -209,7 +209,7 @@ Error: ${error instanceof Error ? error.message : String(error)}`
   let configBaseDir = typeof process !== "undefined" ? process.cwd() : "";
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
     try {
-      const { loadConfig } = await import('./configLoader-YE2CYGDG.js');
+      const { loadConfig } = await import('./configLoader-SHJSRG2A.js');
       const result2 = await loadConfig(process.cwd());
       config = result2.config;
       if (result2.configPath) {
@@ -231,7 +231,7 @@ Error: ${error instanceof Error ? error.message : String(error)}`
       const devServerUrl = await checkDevServer(url);
       if (devServerUrl) {
         console.log(`\u{1F3AD} Running Playwright tests on ${devServerUrl}`);
-        const { runContractTestsPlaywright } = await import('./contractTestRunnerPlaywright-LC5OAVXB.js');
+        const { runContractTestsPlaywright } = await import('./contractTestRunnerPlaywright-Z2AHXSNM.js');
         contract = await runContractTestsPlaywright(componentName, devServerUrl, strictness, config, configBaseDir);
       } else {
         throw new Error(