@d-zero/puppeteer-scroll 4.0.2 → 4.0.4

package/dist/evaluate-with-frame-retry.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Max attempts for each `page.evaluate` call when it fails with a transient
+ * frame error. Chrome may briefly swap or re-attach the main frame during a
+ * long scroll or immediately after navigation, even when the target site is
+ * not doing anything observable. Three attempts with a 200 ms gap absorbs
+ * the typical re-attach window without masking a genuinely broken page.
+ */
+export declare const MAX_EVALUATE_RETRIES = 3;
+export declare const DETACHED_RETRY_DELAY_MS = 200;
+/**
+ * Transient errors that occur when `page.evaluate` lands inside Puppeteer's
+ * own frame-swap or session-teardown window. Retrying after a short delay
+ * usually succeeds because the new execution context is then in place.
+ * @param error - Error caught from `page.evaluate`.
+ * @returns `true` when the error is a known transient frame/session error.
+ * @example
+ * ```ts
+ * try {
+ *   await page.evaluate(...);
+ * } catch (error) {
+ *   if (isTransientFrameError(error)) {
+ *     // retry after a short delay
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export declare function isTransientFrameError(error: unknown): boolean;
+/**
+ * Retries `evaluator` (typically a `page.evaluate` call) when it fails with
+ * a transient frame error. Non-transient errors are re-thrown immediately.
+ *
+ * Used both inside long-running scroll loops and around the single
+ * `page.evaluate` calls that bracket them, so that Chrome's brief
+ * post-navigation main-frame swap does not surface as an unrecoverable
+ * "Attempted to use detached Frame" error in the caller.
+ * @template T - Evaluator return type.
+ * @param evaluator - Thunk that performs a single `page.evaluate` call.
+ * @returns Whatever `evaluator` returns on success.
+ * @example
+ * ```ts
+ * const scrollHeight = await evaluateWithFrameRetry(() =>
+ *   page.evaluate(() => document.body.scrollHeight),
+ * );
+ * ```
+ */
+export declare function evaluateWithFrameRetry<T>(evaluator: () => Promise<T>): Promise<T>;

package/dist/evaluate-with-frame-retry.js

@@ -0,0 +1,66 @@
+/**
+ * Max attempts for each `page.evaluate` call when it fails with a transient
+ * frame error. Chrome may briefly swap or re-attach the main frame during a
+ * long scroll or immediately after navigation, even when the target site is
+ * not doing anything observable. Three attempts with a 200 ms gap absorbs
+ * the typical re-attach window without masking a genuinely broken page.
+ */
+export const MAX_EVALUATE_RETRIES = 3;
+export const DETACHED_RETRY_DELAY_MS = 200;
+/**
+ * Transient errors that occur when `page.evaluate` lands inside Puppeteer's
+ * own frame-swap or session-teardown window. Retrying after a short delay
+ * usually succeeds because the new execution context is then in place.
+ * @param error - Error caught from `page.evaluate`.
+ * @returns `true` when the error is a known transient frame/session error.
+ * @example
+ * ```ts
+ * try {
+ *   await page.evaluate(...);
+ * } catch (error) {
+ *   if (isTransientFrameError(error)) {
+ *     // retry after a short delay
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export function isTransientFrameError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /Attempted to use detached Frame|Session closed|Execution context was destroyed/i.test(error.message);
+}
+/**
+ * Retries `evaluator` (typically a `page.evaluate` call) when it fails with
+ * a transient frame error. Non-transient errors are re-thrown immediately.
+ *
+ * Used both inside long-running scroll loops and around the single
+ * `page.evaluate` calls that bracket them, so that Chrome's brief
+ * post-navigation main-frame swap does not surface as an unrecoverable
+ * "Attempted to use detached Frame" error in the caller.
+ * @template T - Evaluator return type.
+ * @param evaluator - Thunk that performs a single `page.evaluate` call.
+ * @returns Whatever `evaluator` returns on success.
+ * @example
+ * ```ts
+ * const scrollHeight = await evaluateWithFrameRetry(() =>
+ *   page.evaluate(() => document.body.scrollHeight),
+ * );
+ * ```
+ */
+export async function evaluateWithFrameRetry(evaluator) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_EVALUATE_RETRIES; attempt++) {
+        try {
+            return await evaluator();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isTransientFrameError(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, DETACHED_RETRY_DELAY_MS));
+        }
+    }
+    throw lastError;
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { scrollAllOver } from './scroll-all-over.js';
+export { evaluateWithFrameRetry, isTransientFrameError, } from './evaluate-with-frame-retry.js';

package/dist/index.js

@@ -1 +1,2 @@
 export { scrollAllOver } from './scroll-all-over.js';
+export { evaluateWithFrameRetry, isTransientFrameError, } from './evaluate-with-frame-retry.js';

package/dist/scroll-all-over.js

@@ -1,4 +1,5 @@
 import { delay } from '@d-zero/shared/delay';
+import { evaluateWithFrameRetry } from './evaluate-with-frame-retry.js';
 import { resolveValue } from './resolve-value.js';
 /**
  * Number of consecutive iterations without scroll progress before bailing out.
@@ -43,14 +44,14 @@ export async function scrollAllOver(page, options) {
     const interval = options?.interval ?? DEFAULT_INTERVAL;
     const distance = options?.distance;
     let currentScrollY = 0;
-    let scrollHeight = await page.evaluate(() => document.body.scrollHeight);
+    let scrollHeight = await evaluateWithFrameRetry(() => page.evaluate(() => document.body.scrollHeight));
     let prevScrollY = -1;
     let stuckCount = 0;
     while (Math.ceil(currentScrollY) < Math.ceil(scrollHeight)) {
         // Force a minimum of 1 px so a user-supplied 0/negative distance
         // cannot stall the loop into the stuck-detection bail out.
         const stepDistance = distance === undefined ? null : Math.max(1, resolveValue(distance));
-        [currentScrollY, scrollHeight] = await page.evaluate((step, ratioMin, ratioMax) => {
+        [currentScrollY, scrollHeight] = await evaluateWithFrameRetry(() => page.evaluate((step, ratioMin, ratioMax) => {
             // When step is null, sample a random fraction of the viewport
             // height so each scroll feels less mechanical.
             const actualStep = step ??
@@ -61,7 +62,7 @@ export async function scrollAllOver(page, options) {
                 Math.ceil(globalThis.scrollY + globalThis.innerHeight),
                 Math.ceil(document.body.scrollHeight),
             ];
-        }, stepDistance, DEFAULT_DISTANCE_RATIO_MIN, DEFAULT_DISTANCE_RATIO_MAX);
+        }, stepDistance, DEFAULT_DISTANCE_RATIO_MIN, DEFAULT_DISTANCE_RATIO_MAX));
         options?.logger?.(currentScrollY, scrollHeight, 'Scrolling');
         if (currentScrollY === prevScrollY) {
             stuckCount++;
@@ -77,10 +78,10 @@ export async function scrollAllOver(page, options) {
         await delay(interval);
     }
     options?.logger?.(currentScrollY, scrollHeight, 'End of page');
-    await page.evaluate(() => {
+    await evaluateWithFrameRetry(() => page.evaluate(() => {
         // Move the scroll position to the top of the page.
         globalThis.scrollTo(0, 0);
-    });
+    }));
     await delay(400);
     options?.logger?.(currentScrollY, scrollHeight, 'End of page');
     await delay(400);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d-zero/puppeteer-scroll",
-	"version": "4.0.2",
+	"version": "4.0.4",
 	"description": "Scroll function for puppeteer",
 	"author": "D-ZERO",
 	"license": "MIT",
@@ -36,5 +36,5 @@
 		"url": "https://github.com/d-zero-dev/tools.git",
 		"directory": "packages/@d-zero/puppeteer-scroll"
 	},
-	"gitHead": "16c831105a12bb635d49130e7f5add25b6643c40"
+	"gitHead": "9a26e6d8c1e996684691055ffc070547344b21e9"
 }