@tempo-ai/visual-review 0.0.113-staging.2 → 0.0.113-staging.4

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-OT7EUYFD.js")).main(commandArgs);
     case "claim":
       return await (await import("./claim-J654JAS6.js")).main(commandArgs);
     case "report":

package/dist/{chunk-AX52T3IT.js → chunk-W3EZWPOB.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 = [
@@ -4202,6 +4246,16 @@ import os from "os";
 import path6 from "path";
 var PRE_BOOT_CLOCK_SLACK_MS = 5 * 60 * 1e3;
 
+// ../tempo-devserver/install-environment-fallback.ts
+function missingInstallEnvironment(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /(?:^|[\s/"'])(?:docker|pnpm|yarn|bun)(?:["'])?: (?:command )?not found\b/im.test(
+    message
+  ) || /['"](?:docker|pnpm|yarn|bun)['"] is not recognized as an internal or external command/i.test(
+    message
+  ) || /cannot connect to the docker daemon/i.test(message) || /is the docker daemon running\?/i.test(message);
+}
+
 // ../tempo-devserver/tempo-devserver.ts
 import { spawn as spawn5 } from "child_process";
 import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
@@ -4825,7 +4879,7 @@ async function parcelEventToFileEvent(event, rootInfo) {
 // ../tempo-sdk/package.json
 var package_default = {
   name: "tempo-sdk",
-  version: "0.0.45",
+  version: "0.0.48",
   type: "module",
   description: "Tempo SDK \u2014 Vite, Next.js, and Expo plugins for JSX annotation and shared page/storyboard types",
   repository: {
@@ -4906,7 +4960,7 @@ var package_default = {
     demo: "TEMPO=true pnpm --filter @tempo-modules/vite-annotate-plugin-demo dev",
     "demo:nextjs": "TEMPO=true pnpm --filter @tempo-modules/tempo-sdk-nextjs-demo dev",
     test: "vitest run",
-    "test:browser": "vitest run canvas-capture-determinism-browser.test.ts canvas-host-vite-e2e.test.ts canvas-host-packed-sdk-e2e.test.ts error-tracking-e2e.test.ts",
+    "test:browser": "vitest run asset-live-preview-browser.test.ts asset-popover-lifecycle-browser.test.ts component-controls-browser.test.ts canvas-controls-browser.test.ts canvas-capture-determinism-browser.test.ts canvas-host-vite-e2e.test.ts canvas-host-packed-sdk-e2e.test.ts error-tracking-e2e.test.ts",
     "test:watch": "vitest",
     "test:nextjs:unit": "vitest run nextjs-loader.test.ts nextjs-wrapper.test.ts nextjs-fixtures.test.ts nextjs-published.test.ts",
     "test:nextjs:integration": "vitest run nextjs-e2e-correctness.test.ts",
@@ -7301,6 +7355,7 @@ async function walkPagesDir(directory, collector) {
 var CanvasRegistry = class {
   constructor(projectRoot, tempoRoot, _pagesDir, options) {
     this.pendingRequestedCanvasPaths = null;
+    this.requestedThisSession = /* @__PURE__ */ new Set();
     this.requestedCanvasesQueue = Promise.resolve();
     this.projectRoot = projectRoot;
     this.tempoRoot = tempoRoot;
@@ -7338,9 +7393,31 @@ var CanvasRegistry = class {
   async resetRequestedCanvases() {
     await this.runRequestedCanvasesExclusive(async () => {
       this.pendingRequestedCanvasPaths = null;
+      this.requestedThisSession.clear();
       await rm3(this.requestedCanvasesPath, { force: true });
     });
   }
+  /**
+   * Drop demand registrations inherited from an older host session without
+   * erasing canvases already requested through this registry instance.
+   *
+   * Canvas admission may run while first-time initialization is queued. The
+   * registry queue makes both orderings safe: a reset that wins clears the old
+   * file before admission writes it, while a reset that follows admission
+   * observes the current-session request and preserves the file.
+   */
+  async resetStaleRequestedCanvases() {
+    await this.runRequestedCanvasesExclusive(async () => {
+      const requestedPaths = [...this.requestedThisSession];
+      this.pendingRequestedCanvasPaths = requestedPaths;
+      if (requestedPaths.length === 0) {
+        await rm3(this.requestedCanvasesPath, { force: true });
+      } else {
+        await this.writeRequestedCanvasPaths(requestedPaths);
+      }
+      this.pendingRequestedCanvasPaths = null;
+    });
+  }
   requestedPathToAbsolutePath(relativePath) {
     if (typeof relativePath !== "string" || relativePath.length === 0) {
       return null;
@@ -7465,6 +7542,7 @@ var CanvasRegistry = class {
     }
     return this.runRequestedCanvasesExclusive(async () => {
       const requestedPath = this.toRequestedPath(absolutePath);
+      this.requestedThisSession.add(requestedPath);
       const pruned = await this.pruneDeletedRequestedPaths(
         await this.readRequestedCanvasPaths()
       );
@@ -9523,9 +9601,24 @@ var TempoDevServer = class _TempoDevServer {
         }
         this.state.dependenciesInstalled = false;
         await this.persistStatus();
-        for (const step of steps) {
+        try {
+          for (const step of steps) {
+            throwIfLaunchAborted(signal);
+            await runInstallStep(step, signal);
+          }
+        } catch (error) {
           throwIfLaunchAborted(signal);
-          await runInstallStep(step, signal);
+          if (!steps.some((step) => step.label === "custom tempo install") || !missingInstallEnvironment(error))
+            throw error;
+          const localSteps = await this.buildInstallSteps(false, false);
+          if (!localSteps.length) throw error;
+          console.warn(
+            "[tempo-devserver] The configured installer needs unavailable local tooling; trying a local dependency install for this launch."
+          );
+          for (const step of localSteps) {
+            throwIfLaunchAborted(signal);
+            await runInstallStep(step, signal);
+          }
         }
       };
       while (_TempoDevServer.installBarriers.has(this.projectRoot)) {
@@ -9555,9 +9648,9 @@ var TempoDevServer = class _TempoDevServer {
       throw error;
     }
   }
-  async buildInstallSteps(forceInstall) {
+  async buildInstallSteps(forceInstall, useConfiguredScript = true) {
     const configuredInstall = this.config.scripts.install.trim();
-    if (!looksLikeGeneratedInstallScript(configuredInstall)) {
+    if (useConfiguredScript && !looksLikeGeneratedInstallScript(configuredInstall)) {
       if (!forceInstall && await this.projectRootInstallReady() && await installCompletedForCurrentDeps(this.tempoRoot) && await this.tempoInstallReady()) {
         devLog("supervisor:custom_install_skipped_premat", {
           projectRoot: this.projectRoot,
@@ -9617,7 +9710,7 @@ var TempoDevServer = class _TempoDevServer {
         markerRoots: [this.tempoRoot]
       });
     }
-    if (!rootManager && !tempoManager) {
+    if (useConfiguredScript && !rootManager && !tempoManager) {
       steps.push({
         cwd: this.commandCwd,
         command: configuredInstall,
@@ -10211,7 +10304,7 @@ var TempoDevServer = class _TempoDevServer {
       const firstInitialize = !this.state.initialized;
       const hostAlive = this.activeHostHasLivenessAuthority();
       if (firstInitialize && !hostAlive) {
-        await this.registry.resetRequestedCanvases();
+        await this.registry.resetStaleRequestedCanvases();
       }
       const reconcileResult = await this.enqueueReconcile(
         "initialize",
@@ -13974,4 +14067,4 @@ export {
   buildBaselineCaptureArgs,
   main
 };
-//# sourceMappingURL=chunk-AX52T3IT.js.map
+//# sourceMappingURL=chunk-W3EZWPOB.js.map