@tempo-ai/visual-review 0.0.113-staging.1 → 0.0.113-staging.3

package/dist/bin.js

@@ -6,7 +6,7 @@ async function main(argv = process.argv.slice(2)) {
   const [command, ...commandArgs] = argv;
   switch (command) {
     case "capture":
-      return await (await import("./cli-32JWCJ2S.js")).main(commandArgs);
+      return await (await import("./cli-AVHP73RY.js")).main(commandArgs);
     case "claim":
       return await (await import("./claim-J654JAS6.js")).main(commandArgs);
     case "report":

package/dist/{chunk-AX52T3IT.js → chunk-MENKBHDB.js}

@@ -134,6 +134,7 @@ var SETTLE_STEPS = [
   "content-quiet",
   "paint"
 ];
+var VIDEO_FRAME_WAIT_CAP_MS = 2e3;
 var DEFAULT_SETTLE_QUIET_MS = 300;
 var DEFAULT_SETTLE_STEP_TIMEOUT_MS = 15e3;
 var DEFAULT_SETTLE_POLL_MS = 50;
@@ -209,22 +210,48 @@ function buildSettleWaitScript(options) {
 
       var quietKey = null;
       var quietSince = 0;
+      // When a rendered video was first seen without a decoded frame, and how
+      // long that may hold the quiet window before we give up on it.
+      var videoWaitStartedAt = null;
+      var videoWaitCapMs = ${VIDEO_FRAME_WAIT_CAP_MS};
       // Images that take part in the capture: laid out and not hidden. A
       // hidden responsive variant never starts native lazy loading and must
       // not hold the window; a rendered lazy image never starts either,
       // because a capture does not scroll, so it is asked for eagerly.
-      function renderedImages(target) {
-        var all = Array.prototype.slice.call(target.querySelectorAll('img'));
+      function renderedMatches(target, tag) {
+        var all = Array.prototype.slice.call(target.querySelectorAll(tag));
         var rendered = [];
         for (var i = 0; i < all.length; i++) {
-          var img = all[i];
-          if (img.getClientRects().length === 0) continue;
-          var visibility = getComputedStyle(img).visibility;
+          var el = all[i];
+          if (el.getClientRects().length === 0) continue;
+          var visibility = getComputedStyle(el).visibility;
           if (visibility === 'hidden' || visibility === 'collapse') continue;
-          rendered.push(img);
+          rendered.push(el);
         }
         return rendered;
       }
+      function renderedImages(target) {
+        return renderedMatches(target, 'img');
+      }
+      // A video paints its current frame only once that frame is DECODED.
+      // HAVE_CURRENT_DATA (2) is exactly that bar.
+      //
+      // Everything else here is about FAILING OPEN. The baseline lane runs
+      // this step strict, so a video that can never reach that bar would turn
+      // a capture that used to succeed into a settle.content-quiet timeout \u2014
+      // for every storyboard in the repo, not just ones we had in mind. So a
+      // video only holds the window while it is plausibly ON ITS WAY to a
+      // frame: an errored element, one with no source at all, and one the page
+      // explicitly opted out of loading (preload="none", whose poster-or-
+      // nothing paint is already deterministic) are all treated as finished.
+      function videoFrameReady(video) {
+        if (video.error) return true;
+        if (video.preload === 'none') return true;
+        var networkState = video.networkState;
+        if (networkState === 0 /* NETWORK_EMPTY */) return true;
+        if (networkState === 3 /* NETWORK_NO_SOURCE */) return true;
+        return video.readyState >= 2 /* HAVE_CURRENT_DATA */;
+      }
       function contentQuiet() {
         var target = document.querySelector(selector);
         if (!target) return false;
@@ -240,6 +267,23 @@ function buildSettleWaitScript(options) {
             return false;
           }
         }
+        // Second line of defence behind videoFrameReady's fail-open rules: a
+        // video that is legitimately loading can still stall forever (a dev
+        // server that never answers, a huge asset). Waiting is an OPTIMISATION
+        // for baseline stability, never a reason to fail a capture, so the
+        // whole video wait is bounded \u2014 past the cap we capture whatever is
+        // on screen, exactly as we did before videos were considered at all.
+        var videos = renderedMatches(target, 'video');
+        for (var w = 0; w < videos.length; w++) {
+          if (!videoFrameReady(videos[w])) {
+            if (videoWaitStartedAt === null) videoWaitStartedAt = now();
+            if (now() - videoWaitStartedAt < videoWaitCapMs) {
+              quietKey = null;
+              return false;
+            }
+            break;
+          }
+        }
         var rect = target.getBoundingClientRect();
         var text = target.innerText || '';
         var key = [
@@ -13974,4 +14018,4 @@ export {
   buildBaselineCaptureArgs,
   main
 };
-//# sourceMappingURL=chunk-AX52T3IT.js.map
+//# sourceMappingURL=chunk-MENKBHDB.js.map