@validate.qa/runner 1.0.101 → 1.0.103

package/dist/{chunk-CO5KHIVX.mjs → chunk-TK5KEGNW.mjs}

@@ -1,7 +1,7 @@
 import {
   dist_exports,
   init_dist
-} from "./chunk-IGXGSDE3.mjs";
+} from "./chunk-OTKJZIOD.mjs";
 import {
   __commonJS,
   __require,

package/dist/{chunk-FQUH2PU2.mjs → chunk-WVLBQDFP.mjs}

@@ -1,7 +1,7 @@
 import {
   dist_exports,
   init_dist
-} from "./chunk-IGXGSDE3.mjs";
+} from "./chunk-OTKJZIOD.mjs";
 import {
   __commonJS,
   __esm,
@@ -67455,23 +67455,79 @@ var require_harness_init_script = __commonJS({
     exports.isHarnessInitConsoleLine = isHarnessInitConsoleLine;
     exports.stripHarnessConsoleEntries = stripHarnessConsoleEntries;
     var node_crypto_1 = __require("crypto");
+    var shared_1 = (init_dist(), __toCommonJS(dist_exports));
     exports.HARNESS_INIT_SOURCE_URL = `vqa-harness-init-${(0, node_crypto_1.randomBytes)(4).toString("hex")}.js`;
+    var TRANSITION_LOOP_LIMIT = 8;
+    var TRANSITION_LOOP_WINDOW_MS = 1e3;
     function withHarnessSourceUrl(content) {
       return `${content}
 //# sourceURL=${exports.HARNESS_INIT_SOURCE_URL}`;
     }
     function buildAnimationDisablingSource(opts) {
+      const finishTransitions = opts.finishTransitions ?? (0, shared_1.parseBoolFlag)(process.env.HARNESS_FINISH_CSS_TRANSITIONS);
+      const css = finishTransitions ? "*, *::before, *::after { animation-duration: 0s !important; animation-delay: 0s !important; }" : "*, *::before, *::after { transition-duration: 0s !important; animation-duration: 0s !important; transition-delay: 0s !important; animation-delay: 0s !important; }";
       return withHarnessSourceUrl(`(() => {
+  // An error the browser throws for the page's own value, passed through one of the wrappers below (a bad
+  // adoptedStyleSheets list, animate timing it refuses), is the app's: stock Playwright reports it as a page error.
+  // Thrown from our wrapper, its top frame would be this script, and the console evidence drops such an error as
+  // the runner's own. Our frames come out of its stack, so the app's call is the top frame, as without the harness.
+  // (Under Error.stackTraceLimit the stack then has one or two frames fewer than stock's; the top frame is right.)
+  const own = ${JSON.stringify(exports.HARNESS_INIT_SOURCE_URL)};
+  const appError = (e) => {
+    try {
+      const stack = e !== null && typeof e === 'object' ? e.stack : undefined;
+      if (typeof stack === 'string' && stack.includes(own)) e.stack = stack.split('\\n').filter((line) => !line.includes(own)).join('\\n');
+    } catch (x) {}
+    return e;
+  };
   // Layer 1: CSS transitions and animations - instant, not removed
   // (duration 0s preserves final state; 'none' would prevent keyframes from completing)
+  // The rule goes in a constructed stylesheet on document.adoptedStyleSheets, which adds no node to the DOM:
+  // a <style> element changed what the test sees (locator('style') and 'head > *' counts, document.styleSheets,
+  // an iframe's empty head), so a spec stock Playwright passes failed. The <style> is the fallback for a
+  // browser with no constructable stylesheets.
+  let adopted = false;
   try {
+    if (typeof CSSStyleSheet === 'function' && typeof Document === 'function' && 'adoptedStyleSheets' in Document.prototype) {
+      const sheet = new CSSStyleSheet();
+      sheet.replaceSync(${JSON.stringify(css)});
+      document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+      adopted = true;
+      // A page that assigns the list without spreading it (document.adoptedStyleSheets = [mine]) would drop the
+      // harness sheet and bring animations back: keep it, last, on every assignment. A bad value (not iterable,
+      // or a list the browser refuses) goes to the browser, which throws its own error as the app's (appError).
+      try {
+        const desc = Object.getOwnPropertyDescriptor(Document.prototype, 'adoptedStyleSheets');
+        if (desc && desc.get && desc.set) {
+          Object.defineProperty(document, 'adoptedStyleSheets', {
+            configurable: true,
+            enumerable: desc.enumerable,
+            get() { return desc.get.call(document); },
+            set(value) {
+              try {
+                if (value === null || (typeof value !== 'object' && typeof value !== 'function') || typeof value[Symbol.iterator] !== 'function') {
+                  desc.set.call(document, value);
+                  return;
+                }
+                const list = [...value];
+                desc.set.call(document, list.includes(sheet) ? list : [...list, sheet]);
+              } catch (e) {
+                throw appError(e);
+              }
+            },
+          });
+        }
+      } catch (e) {}
+    }
+  } catch (e) {}
+  if (!adopted) try {
     let applied = false;
     const apply = () => {
       if (applied) return true;
       const root = document.head || document.documentElement;
       if (!root) return false;
       const style = document.createElement('style');
-      style.textContent = '*, *::before, *::after { transition-duration: 0s !important; animation-duration: 0s !important; transition-delay: 0s !important; animation-delay: 0s !important; }';
+      style.textContent = ${JSON.stringify(css)};
       root.appendChild(style);
       applied = true;
       return true;
@@ -67493,19 +67549,96 @@ ${opts.hideWebdriver ? `
   try {
     Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
   } catch (e) {}
+` : ""}
+${finishTransitions ? `
+  // Layer 1b: CSS transitions run, and are finished as they start, so transitionend fires.
+  // - finish() is deferred to a task: called inside the transitionrun dispatch (or a microtask of it) after a
+  //   real input event, Chromium finishes the transition but never fires its transitionstart/transitionend.
+  // - setTimeout and performance.now are the ones present when this script runs, before the page's own
+  //   scripts: fake timers the page installs later cannot hold a finish back.
+  // - The subtree is walked only for a pseudo-element's transition (its animations hang off the element).
+  // - An element whose same transition restarts more than ${TRANSITION_LOOP_LIMIT} times within ${TRANSITION_LOOP_WINDOW_MS} ms (an app that starts it again on
+  //   each transitionend: carousel, pulse) is left to run at its own pace from then on, instead of cycling at
+  //   frame rate for the rest of the run.
+  try {
+    const st = setTimeout;
+    const perf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : null;
+    const now = perf ? perf.now.bind(perf) : Date.now;
+    const seen = new WeakMap();
+    const looping = (el, key) => {
+      let byKey = seen.get(el);
+      if (!byKey) { byKey = new Map(); seen.set(el, byKey); }
+      const t = now();
+      let s = byKey.get(key);
+      if (s && s.loop) return true;
+      if (!s || t - s.since > ${TRANSITION_LOOP_WINDOW_MS}) { s = { n: 0, since: t, loop: false }; byKey.set(key, s); }
+      s.n += 1;
+      if (s.n > ${TRANSITION_LOOP_LIMIT}) s.loop = true;
+      return s.loop;
+    };
+    window.addEventListener('transitionrun', (ev) => {
+      try {
+        const el = ev && ev.target;
+        if (!el || typeof el.getAnimations !== 'function' || typeof CSSTransition !== 'function') return;
+        const pseudo = ev.pseudoElement || '';
+        if (looping(el, ev.propertyName + '|' + pseudo)) return;
+        for (const a of (pseudo ? el.getAnimations({ subtree: true }) : el.getAnimations())) {
+          if (a instanceof CSSTransition && a.transitionProperty === ev.propertyName && a.effect
+            && a.effect.target === el && (a.effect.pseudoElement || '') === pseudo) {
+            st(() => { try { a.finish(); } catch (e) {} }, 0);
+          }
+        }
+      } catch (e) {}
+    }, true);
+  } catch (e) {}
 ` : ""}
   // Layer 2: Web Animations API - make instant instead of no-op
   // (preserves animation completion callbacks that app code may depend on)
+  // Timing the browser refuses (a negative, NaN or non-'auto' duration, a delay that is not finite) goes to the
+  // browser as the page wrote it: zeroed, it raised no TypeError, so a page error stock Playwright reports was hidden.
+  // Options that are not a plain object (an array, a class instance) keep what they inherit: the browser reads
+  // every timing member through the prototype chain, and an array's inherited fill() is a TypeError. A copy kept
+  // only own properties, so the error was hidden; a proxy overrides only duration and delay.
   try {
     const origAnimate = Element.prototype.animate;
+    const refused = (options) => {
+      try {
+        if (options === undefined || options === null) return false;
+        if (typeof options !== 'object' && typeof options !== 'function') return !(Number(options) >= 0);
+        const duration = options.duration;
+        if (duration !== undefined && duration !== 'auto' && !(typeof duration === 'number' && duration >= 0)) return true;
+        const delay = options.delay;
+        return delay !== undefined && !Number.isFinite(Number(delay));
+      } catch (e) {
+        return true;
+      }
+    };
+    const instant = (options) => {
+      try {
+        // Plain: its prototype is null or an Object.prototype (of any frame's realm), so it inherits no timing.
+        const proto = Object.getPrototypeOf(options);
+        if (proto !== null && Object.getPrototypeOf(proto) !== null && typeof Proxy === 'function') {
+          // The proxy's target is an empty object, not the options: a target with a read-only, non-configurable
+          // duration or delay (a frozen instance, Object.create with a descriptor) would make returning 0 a proxy
+          // invariant TypeError. Every other member is read from the options, the options as the receiver.
+          return new Proxy({}, { get: (_target, key) => (key === 'duration' || key === 'delay' ? 0 : Reflect.get(options, key)) });
+        }
+      } catch (e) {}
+      return Object.assign({}, options, { duration: 0, delay: 0 });
+    };
     if (typeof origAnimate === 'function') {
       Element.prototype.animate = function (keyframes, options) {
-        if (typeof options === 'object' && options !== null) {
-          options = Object.assign({}, options, { duration: 0, delay: 0 });
-        } else {
-          options = 0; // covers number, undefined, and any other type
+        try {
+          if (refused(options)) return origAnimate.call(this, keyframes, options);
+          if (typeof options === 'object' && options !== null) {
+            options = instant(options);
+          } else {
+            options = 0; // covers number, undefined, and any other type
+          }
+          return origAnimate.call(this, keyframes, options);
+        } catch (e) {
+          throw appError(e);
         }
-        return origAnimate.call(this, keyframes, options);
       };
     }
   } catch (e) {}

package/dist/{chunk-2OKZY3WN.mjs → chunk-YI3ZC2XI.mjs}

@@ -1,9 +1,9 @@
 import {
   require_run_write_guard
-} from "./chunk-BBTK6OX6.mjs";
+} from "./chunk-BECCGMU4.mjs";
 import {
   require_survey_network_guard
-} from "./chunk-SN3PN4G4.mjs";
+} from "./chunk-36AWDKPL.mjs";
 import {
   __commonJS,
   __require

package/dist/{chunk-XZUUBMP3.mjs → chunk-YIM746WO.mjs}

@@ -1,7 +1,7 @@
 import {
   require_test_inbox_broker,
   require_verification_inbox
-} from "./chunk-FQUH2PU2.mjs";
+} from "./chunk-WVLBQDFP.mjs";
 import {
   __commonJS,
   __require