waygraph 0.12.36 → 0.12.38

package/dist/cli.js

@@ -711,6 +711,8 @@ async function installOverlay(page, title) {
           const cursor = document.getElementById("wg-cursor");
           if (!cursor) return;
           const travel = ms || 600;
+          window.__wgCursorPos = { x: Number(x) || 0, y: Number(y) || 0 };
+          window.__wgCursorTravelUntil = Date.now() + (instant ? 0 : travel) + 40;
           cursor.style.setProperty("--wg-cursor-ms", travel + "ms");
           if (instant) {
             const prev = cursor.style.transition;
@@ -811,6 +813,54 @@ async function installOverlay(page, title) {
           let settled = zoom <= 1;
           const settleAt = Date.now() + camMs;
           const style = { size, weight, focus, color };
+          // Screen Studio / Screenify: dead zone follow (see followTick).
+          const deadFrac = 0.5;
+          let lastPanAt = 0;
+          const readCursorViewport = () => {
+            const cursor = document.getElementById("wg-cursor");
+            if (cursor && cursor.style.opacity !== "0") {
+              const r = cursor.getBoundingClientRect();
+              if (r.width || r.height || r.left || r.top) {
+                return { x: r.left, y: r.top };
+              }
+            }
+            if (window.__wgCursorPos) return window.__wgCursorPos;
+            return null;
+          };
+          const followTick = () => {
+            if (!followMouse || !settled || window.__wgCameraLock) return;
+            if (!window.__wgSetCamera || !window.__wgViewportToDoc) return;
+            const cam = window.__wgCamera;
+            if (!cam || !(cam.scale > 1.001)) return;
+            // Skip while the demo cursor is mid CSS travel - reading a
+            // mid-lerp rect makes the camera chase noise and teleport.
+            if (window.__wgCursorTravelUntil && Date.now() < window.__wgCursorTravelUntil) {
+              return;
+            }
+            const pos = readCursorViewport();
+            if (!pos) return;
+            const vw = window.innerWidth;
+            const vh = window.innerHeight;
+            const dx = pos.x - vw / 2;
+            const dy = pos.y - vh / 2;
+            const deadX = (vw * deadFrac) / 2;
+            const deadY = (vh * deadFrac) / 2;
+            let ox = 0;
+            let oy = 0;
+            if (dx > deadX) ox = dx - deadX;
+            else if (dx < -deadX) ox = dx + deadX;
+            if (dy > deadY) oy = dy - deadY;
+            else if (dy < -deadY) oy = dy + deadY;
+            if (ox === 0 && oy === 0) return;
+            const now = Date.now();
+            if (now - lastPanAt < 120) return;
+            lastPanAt = now;
+            // Partial gain - never yank the full overflow in one pan.
+            const gain = 0.35;
+            const nx = cam.cx + (ox / cam.scale) * gain;
+            const ny = cam.cy + (oy / cam.scale) * gain;
+            window.__wgSetCamera(nx, ny, cam.scale, 280);
+          };
           const tick = () => {
             const el = document.querySelector(sel);
             if (el && window.__wgPositionRing) {
@@ -823,32 +873,34 @@ async function installOverlay(page, title) {
               );
             }
             if (!settled && Date.now() >= settleAt) settled = true;
+            followTick();
             window.__wgRingRaf = requestAnimationFrame(tick);
           };
           if (zoom > 1 && window.__wgSetCamera) {
             const el0 = document.querySelector(sel);
             if (el0) {
-              const r0 = el0.getBoundingClientRect();
               const already =
                 window.__wgCamera && window.__wgCamera.scale > 1.001;
-              // Already zoomed (zoomOut:false chain): short pan, not full zoom-in.
               const dur = already ? Math.min(camMs, 420) : camMs;
-              window.__wgSetCamera(
-                r0.left + r0.width / 2,
-                r0.top + r0.height / 2,
-                zoom,
-                dur,
-              );
+              // Focus must be document-space, not raw getBoundingClientRect
+              // (viewport) - otherwise already-zoomed pans fight the cursor.
+              const pt = window.__wgElDocPoint
+                ? window.__wgElDocPoint(el0)
+                : {
+                    x: el0.getBoundingClientRect().left + el0.getBoundingClientRect().width / 2,
+                    y: el0.getBoundingClientRect().top + el0.getBoundingClientRect().height / 2,
+                  };
+              window.__wgCameraLock = true;
+              window.__wgSetCamera(pt.x, pt.y, zoom, dur);
+              setTimeout(() => {
+                window.__wgCameraLock = false;
+              }, dur + 40);
             }
           }
           window.__wgRingRaf = requestAnimationFrame(tick);
+          // Real mouse only seeds cursor pos; dead-zone follow runs in RAF.
           const onMove = (ev) => {
-            if (!followMouse || !settled) return;
-            if (!window.__wgSetCamera) return;
-            const cam = window.__wgCamera;
-            const scale = (cam && cam.scale > 1 ? cam.scale : zoom) || zoom;
-            if (!(scale > 1)) return;
-            window.__wgSetCamera(ev.clientX, ev.clientY, scale, 140);
+            window.__wgCursorPos = { x: ev.clientX, y: ev.clientY };
           };
           window.addEventListener("mousemove", onMove, { passive: true });
           window.__wgRingTrack = onMove;
@@ -893,7 +945,34 @@ async function installOverlay(page, title) {
           // rings; only resetCameraZoom / teardown call __wgClearZoom.
         };
         // Screen Studio-style camera: scale <body>, keep overlays on <html> fixed.
-        window.__wgCamera = { scale: 1, cx: 0, cy: 0 };
+        // Focus (cx,cy) is DOCUMENT space (pre-transform). Viewport mouse/rects
+        // must go through __wgViewportToDoc before SetCamera.
+        window.__wgCamera = {
+          scale: 1,
+          cx: window.innerWidth / 2,
+          cy: window.innerHeight / 2,
+        };
+        window.__wgCameraLock = false;
+        window.__wgViewportToDoc = (vx, vy) => {
+          const cam = window.__wgCamera || {
+            scale: 1,
+            cx: window.innerWidth / 2,
+            cy: window.innerHeight / 2,
+          };
+          const s = cam.scale > 1.001 ? cam.scale : 1;
+          if (s <= 1.001) return { x: vx, y: vy };
+          return {
+            x: (vx - window.innerWidth / 2) / s + cam.cx,
+            y: (vy - window.innerHeight / 2) / s + cam.cy,
+          };
+        };
+        window.__wgElDocPoint = (el) => {
+          const r = el.getBoundingClientRect();
+          return window.__wgViewportToDoc(
+            r.left + r.width / 2,
+            r.top + r.height / 2,
+          );
+        };
         window.__wgSetCamera = (fx, fy, scale, ms) => {
           const body = document.body;
           if (!body) return;
@@ -961,7 +1040,7 @@ async function installOverlay(page, title) {
             '<div class="wg-todo-head">Checklist</div><ul>' + rows + '</ul>';
           modal.classList.add("wg-todo-on");
         };
-window.__wgResetCamera = () => {
+        window.__wgResetCamera = () => {
           window.__wgSetCamera(window.innerWidth / 2, window.innerHeight / 2, 1);
         };
         window.__wgClearZoom = () => {
@@ -1413,13 +1492,17 @@ async function applyCameraZoom(page, box, zoom, ms) {
     }).catch(() => {});
     return;
   }
-  const cx = box.x + box.width / 2;
-  const cy = box.y + box.height / 2;
+  const vx = box.x + box.width / 2;
+  const vy = box.y + box.height / 2;
   const dur = ms != null ? ms : 650;
   await page
-    .evaluate(({ cx, cy, scale, dur }) => {
-      if (window.__wgSetCamera) window.__wgSetCamera(cx, cy, scale, dur);
-    }, { cx, cy, scale: z, dur })
+    .evaluate(({ vx, vy, scale, dur }) => {
+      if (!window.__wgSetCamera) return;
+      const pt = window.__wgViewportToDoc
+        ? window.__wgViewportToDoc(vx, vy)
+        : { x: vx, y: vy };
+      window.__wgSetCamera(pt.x, pt.y, scale, dur);
+    }, { vx, vy, scale: z, dur })
     .catch(() => {});
 }
 
@@ -1553,16 +1636,9 @@ async function cycleHighlightRings(page, highlights, gatesFast, opts) {
           : h.follow !== undefined
             ? !!h.follow
             : z > 1;
-      const cx = box.x + box.width / 2;
-      const cy = box.y + box.height / 2;
-      if (h.cursor !== false) {
-        await page
-          .evaluate(({ cx, cy, camMs }) => {
-            if (window.__wgMoveCursorTo) window.__wgMoveCursorTo(cx, cy, camMs, false);
-          }, { cx, cy, camMs })
-          .catch(() => {});
-      }
-      // Track first: ring rides visual rect through the zoom (no re-adjust).
+      // Track/zoom first, then park the demo cursor on the LIVE rect.
+      // Placing the cursor on a pre-zoom boundingBox leaves it stranded after
+      // body scale (html cursor is outside the transform).
       await page
         .evaluate(
           ({ sel, label, tone, size, weight, focus, color, zoom, followMouse, camMs }) => {
@@ -1600,7 +1676,21 @@ async function cycleHighlightRings(page, highlights, gatesFast, opts) {
         .catch(() => false);
       const waitMs = alreadyZoomed ? Math.min(camMs, 420) : camMs;
       await new Promise((res) => setTimeout(res, waitMs));
-
+      if (h.cursor !== false) {
+        await page
+          .evaluate(({ sel, ms }) => {
+            const el = document.querySelector(sel);
+            if (!el || !window.__wgMoveCursorTo) return;
+            window.__wgCameraLock = true;
+            const r = el.getBoundingClientRect();
+            window.__wgMoveCursorTo(r.left + r.width / 2, r.top + r.height / 2, ms, false);
+            setTimeout(() => {
+              window.__wgCameraLock = false;
+            }, ms + 40);
+          }, { sel: h.selector, ms: Math.min(280, camMs) })
+          .catch(() => {});
+        await new Promise((res) => setTimeout(res, Math.min(280, camMs)));
+      }
       // Appear settle
       await new Promise((res) => setTimeout(res, fadeMs));
       const authored = resolveFixtureDwellMs(h, { gatesFast, pace });
@@ -1623,6 +1713,14 @@ async function cycleHighlightRings(page, highlights, gatesFast, opts) {
   const last = list.length > 0 ? list[list.length - 1] : null;
   if (!last || last.zoomOut !== false) {
     await resetCameraZoom(page);
+  } else {
+    // Hold lock into the upcoming act click so follow/scroll cannot yank
+    // the camera off the already-centered target (cart teleport bug).
+    await page
+      .evaluate(() => {
+        window.__wgCameraLock = true;
+      })
+      .catch(() => {});
   }
   if (list.length === 0) {
     await hideRing(page);
@@ -2359,12 +2457,16 @@ async function teardownOverlay(page) {
     .catch(() => {});
 }
 
-async function moveCursorTo(page, box, ms) {
+async function moveCursorTo(page, box, ms, opts) {
   const x = box.x + box.width / 2;
   const y = box.y + box.height / 2;
   const travel = Math.max(0, Number(ms) || 0);
+  const keepLock = !!(opts && opts.keepLock);
+  // Freeze camera follow while the demo cursor travels - otherwise dead-zone
+  // pans fight the click target (esp. right-edge cart chrome).
   await page
     .evaluate(({ x, y, ms }) => {
+      window.__wgCameraLock = true;
       if (window.__wgMoveCursorTo) window.__wgMoveCursorTo(x, y, ms);
     }, { x, y, ms: travel })
     .catch(() => {});
@@ -2374,6 +2476,13 @@ async function moveCursorTo(page, box, ms) {
   if (travel > 0) {
     await new Promise((res) => setTimeout(res, travel));
   }
+  if (!keepLock) {
+    await page
+      .evaluate(() => {
+        window.__wgCameraLock = false;
+      })
+      .catch(() => {});
+  }
   return { x, y };
 }
 
@@ -2501,6 +2610,7 @@ function instrumentInteractionHighlighting(page, mem, slowMo, pacing, stubBefore
     proto.click = async function (options) {
       let clickPoint = null;
       let clickTone = "auto";
+      let keptCameraLock = false;
       try {
         await installOverlay(page);
         // Wait until the target is visible BEFORE measuring - otherwise
@@ -2511,6 +2621,20 @@ function instrumentInteractionHighlighting(page, mem, slowMo, pacing, stubBefore
           state: "visible",
           timeout: (options && options.timeout) || 30000,
         }).catch(() => {});
+        // Body-scale camera + Playwright scrollIntoView = teleport storm.
+        // Lock the camera for the whole click when zoomed; force-click so
+        // Playwright does not try to scroll the transformed page.
+        const zoomed = await page
+          .evaluate(() => !!(window.__wgCamera && window.__wgCamera.scale > 1.001))
+          .catch(() => false);
+        if (zoomed) {
+          await page
+            .evaluate(() => {
+              window.__wgCameraLock = true;
+            })
+            .catch(() => {});
+          keptCameraLock = true;
+        }
         const box = await this.boundingBox();
         const narrated = box ? await wasJustNarrated(page) : false;
         if (box && !narrated) {
@@ -2532,8 +2656,18 @@ function instrumentInteractionHighlighting(page, mem, slowMo, pacing, stubBefore
           const stubs = (stubBeforeRef && stubBeforeRef.current) || [];
           const cap = await captionForLocator(page, this, stubs, fallback);
           clickTone = cap.tone;
-          clickPoint = await moveCursorTo(page, box, cursorMs(600));
-          await showRing(page, box, cap.label, cap.tone, {
+          // Already centered from stubBefore zoom: short cursor, keep lock.
+          const travel = zoomed ? cursorMs(160) : cursorMs(600);
+          clickPoint = await moveCursorTo(page, box, travel, {
+            keepLock: zoomed,
+          });
+          // Re-measure after cursor settle - stale pre-travel box teleports the ring.
+          const liveBox = (await this.boundingBox()) || box;
+          clickPoint = {
+            x: liveBox.x + liveBox.width / 2,
+            y: liveBox.y + liveBox.height / 2,
+          };
+          await showRing(page, liveBox, cap.label, cap.tone, {
             size: cap.size,
             weight: cap.weight,
           });
@@ -2545,7 +2679,10 @@ function instrumentInteractionHighlighting(page, mem, slowMo, pacing, stubBefore
         } else if (box) {
           // Ring/caption already handled by narrate() - still move the
           // cursor + pulse the click point, just skip re-showing the ring.
-          clickPoint = await moveCursorTo(page, box, cursorMs(200));
+          const travel = zoomed ? cursorMs(120) : cursorMs(200);
+          clickPoint = await moveCursorTo(page, box, travel, {
+            keepLock: zoomed,
+          });
           clickTone = "planned";
         }
       } catch {
@@ -2561,10 +2698,27 @@ function instrumentInteractionHighlighting(page, mem, slowMo, pacing, stubBefore
         // mock click visually completes before the real one fires.
         await new Promise((res) => setTimeout(res, skipTheater() ? 0 : 500));
       }
-      const result = await originalClick.call(this, options);
-      await new Promise((res) => setTimeout(res, clickPostPop()));
-      await hideRing(page);
-      return result;
+      const zoomedClick = await page
+        .evaluate(() => !!(window.__wgCamera && window.__wgCamera.scale > 1.001))
+        .catch(() => false);
+      const clickOpts =
+        zoomedClick || keptCameraLock
+          ? { ...(options || {}), force: true }
+          : options;
+      try {
+        const result = await originalClick.call(this, clickOpts);
+        await new Promise((res) => setTimeout(res, clickPostPop()));
+        await hideRing(page);
+        return result;
+      } finally {
+        if (keptCameraLock) {
+          await page
+            .evaluate(() => {
+              window.__wgCameraLock = false;
+            })
+            .catch(() => {});
+        }
+      }
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waygraph",
-  "version": "0.12.36",
+  "version": "0.12.38",
   "type": "module",
   "description": "A typed graph of reusable Blocks for driving a browser through E2E flows.",
   "license": "MIT",