@lightcone-ai/daemon 0.18.1 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/recorder/plan-executor.js

@@ -1,4 +1,5 @@
 import { resolveDurationMs } from './phase-duration.js';
+import { humanizedScroll } from '../humanized-scroll.js';
 
 function normalizeText(value) {
   if (typeof value !== 'string') return '';
@@ -228,13 +229,26 @@ function resolveFromY(phase, fallback = null) {
   return Math.round(parsed);
 }
 
+// Delegates to humanizedScroll, which dispatches real CDP touch events so
+// the browser's gesture engine produces native scroll physics (rubber-band,
+// fling inertia, compositor-paced repaints). The old implementation drove
+// `root.scrollTo(...)` in a setTimeout loop inside page.evaluate — visually
+// smooth in isolation, but bypassed the gesture pipeline entirely, which is
+// what made scrolls feel "robotic" on recordings (see the
+// `not natural` thread in docs/scenario-content-creation discussion).
+//
+// `minSteps` is no longer needed (humanizedScroll computes segments from
+// distance + duration). `jitterPx` is forwarded as `pixel_jitter_px`, which
+// humanizedScroll converts into per-touchMove vertical offset.
 async function animateScroll(page, {
   startY = null,
   targetY,
   durationMs,
   easing = 'easeInOutQuad',
   jitterPx = 0,
-  minSteps = 10,
+  // minSteps is accepted but unused — kept in the signature so callers don't
+  // need updating in this refactor.
+  minSteps: _minSteps,  // eslint-disable-line no-unused-vars
 } = {}) {
   if (!Number.isFinite(Number(targetY))) {
     const error = new Error('phase_target_y_required');
@@ -242,53 +256,19 @@ async function animateScroll(page, {
     throw error;
   }
 
-  const normalizedDurationMs = Math.max(0, Number(durationMs) || 0);
-  const normalizedMinSteps = Math.max(1, Number(minSteps) || 1);
-
-  await page.evaluate(async ({
-    startY: evaluateStartY,
-    targetY: evaluateTargetY,
-    durationMs: evaluateDurationMs,
-    easing: evaluateEasing,
-    jitterPx: evaluateJitterPx,
-    minSteps: evaluateMinSteps,
-  }) => {
-    const root = document.scrollingElement || document.documentElement;
-    const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
-    const fromY = Number.isFinite(evaluateStartY) ? evaluateStartY : root.scrollTop;
-    const toY = evaluateTargetY;
-    const delta = toY - fromY;
-
-    const steps = Math.max(evaluateMinSteps, Math.round(Math.max(1, evaluateDurationMs) / 16));
-    const stepDurationMs = evaluateDurationMs <= 0 ? 0 : evaluateDurationMs / steps;
-
-    const applyEasing = (t) => {
-      if (evaluateEasing === 'linear') return t;
-      if (evaluateEasing === 'easeOutQuad') return 1 - ((1 - t) * (1 - t));
-      return t < 0.5
-        ? 2 * t * t
-        : 1 - (Math.pow(-2 * t + 2, 2) / 2);
-    };
-
-    root.scrollTo(0, fromY);
-    for (let index = 1; index <= steps; index += 1) {
-      const t = index / steps;
-      const eased = applyEasing(t);
-      const jitter = evaluateJitterPx > 0 ? ((Math.random() * 2 - 1) * evaluateJitterPx) : 0;
-      root.scrollTo(0, fromY + (delta * eased) + jitter);
-      if (stepDurationMs > 0) {
-        await wait(stepDurationMs);
-      }
-    }
-    root.scrollTo(0, toY);
-  }, {
-    startY,
-    targetY,
-    durationMs: normalizedDurationMs,
-    easing,
-    jitterPx: Math.max(0, Number(jitterPx) || 0),
-    minSteps: normalizedMinSteps,
+  const resolvedFromY = Number.isFinite(Number(startY))
+    ? Number(startY)
+    : await page.evaluate(() => {
+        const root = document.scrollingElement || document.documentElement;
+        return Math.round(root.scrollTop);
+      });
+
+  await humanizedScroll(page, {
+    from_y: resolvedFromY,
+    to_y: Number(targetY),
+    duration_ms: Math.max(0, Number(durationMs) || 0),
+    motion_curve: easing,
+    pixel_jitter_px: Math.max(0, Number(jitterPx) || 0),
   });
 }