@browserless/pdf 13.6.3 → 13.6.5

package/package.json

@@ -2,7 +2,7 @@
   "name": "@browserless/pdf",
   "description": "Convert websites to high-quality PDFs with customizable margins, background printing, and optimized scaling.",
   "homepage": "https://browserless.js.org/#/?id=pdfurl-options",
-  "version": "13.6.3",
+  "version": "13.6.5",
   "main": "src",
   "author": {
     "email": "hello@microlink.io",
@@ -30,8 +30,8 @@
     "website-to-pdf"
   ],
   "dependencies": {
-    "@browserless/goto": "13.6.3",
-    "@browserless/screenshot": "13.6.3",
+    "@browserless/goto": "13.6.5",
+    "@browserless/screenshot": "13.6.5",
     "@kikobeats/time-span": "~1.0.12",
     "debug-logfmt": "~1.4.10",
     "p-reflect": "~2.1.0",
@@ -47,5 +47,5 @@
     "test": "exit 0"
   },
   "license": "MIT",
-  "gitHead": "7bc1c12120186d999a5ddedbcad4e3b5b52fb8fb"
+  "gitHead": "679c9a8f0db8a6a98bb54fd3d19532ea8a64d76b"
 }

package/src/index.js

@@ -22,10 +22,13 @@ const PDF_DEFAULT_OPTS = {
   waitUntil: 'auto'
 }
 
-// Share of the action budget the readiness gate may consume in `auto` mode. The
-// remainder is reserved for the blank-SPA screenshot poll to re-wait, so the
-// gate can't starve the fallback while total prepare stays within one `timeout`.
-const READY_BUDGET_RATIO = 0.5
+// Share of the phase's load allowance the readiness gate may consume in `auto`
+// mode. Pages observed settling in 0.6-3.3s (a hydrating document is the slow
+// end), so a quarter of the allowance — ~3.9s at the default request budget —
+// covers them with margin while keeping the cap well short of the render's
+// share. The gate returns as soon as the page is quiet, so this bounds only a
+// page that never settles.
+const READY_BUDGET_RATIO = 0.25
 
 // Minimum visible characters for the text fast path. Matches the counting cap
 // in `waitForReady`'s snapshot, which stops walking text nodes once reached —
@@ -97,35 +100,57 @@ module.exports = ({ goto, ...gotoOpts } = {}) => {
       return
     }
 
+    // Surfaced to the caller: a page whose readiness could not be confirmed
+    // (`timedOut`) is a poor one to keep rendering on, so a caller reusing this
+    // load across page-ranges can choose a fresh context instead.
+    let readiness
+
     await goto(page, { ...rest, url, waitUntil, waitUntilAuto })
-    async function waitUntilAuto (page) {
+    return readiness
+
+    async function waitUntilAuto (page, { timeout: autoTimeout } = {}) {
       await waitForDomStabilityResult(page)
       const timeout = goto.timeouts.action(rest.timeout)
-      // One action budget shared by the readiness gate and the screenshot poll,
-      // so worst-case prepare stays within a single `timeout` instead of one
-      // per stage.
-      const elapsed = timeSpan()
 
-      // Cheap, navigation-tolerant readiness — no screenshots. Resolves once the
-      // page is visually quiet (height stable, images decoded, load complete),
-      // absorbing the client-side re-navigation that makes a screenshot poll
-      // throw `Execution context was destroyed`. Capped at a share of the budget
-      // so a slow gate still leaves the blank-SPA poll room to re-wait.
-      const ready = await waitForReady(page, { timeout: Math.round(timeout * READY_BUDGET_RATIO) })
-      debug('ready', { ...ready, duration: elapsed() })
+      // The readiness gate waits for a page to settle — page-load work, not a
+      // small action. Budgeting it from `timeouts.action` (timeout/11) gave it
+      // ~1.2s while a hydrating document needs 2-3s, so it timed out on every
+      // tall page and the zero-capture fast path never fired. Budget it from
+      // the load allowance goto actually assigned to this phase; the gate
+      // returns as soon as the page is quiet, so this is a cap, not a cost.
+      const readyTime = timeSpan()
+      const ready = await waitForReady(page, {
+        timeout: Math.round((autoTimeout ?? timeout) * READY_BUDGET_RATIO)
+      })
+      readiness = ready
+      debug('ready', { ...ready, duration: readyTime() })
+
+      // The blank-page poll keeps its own action budget, measured from here so
+      // a slow gate cannot starve it.
+      const elapsed = timeSpan()
 
       // Fast path: the page settled with real painted content in a document
       // taller than the viewport — a visibly rendered image (not a tracking
       // pixel), or enough visible text with webfonts loaded (a pending
       // `font-display: block` font renders text invisible, exactly when a
-      // capture would be white) — so it can't be a blank shell: skip the
+      // capture would be white) — and that content is not `covered` by an
+      // opaque viewport-filling layer (a fixed white loading overlay passes
+      // every other DOM signal while a capture stays white): skip the
       // screenshot poll. Height and viewport come from the same in-page
       // snapshot (`page.viewport()` is null under `defaultViewport: null`),
       // and an unknown viewport skips the fast path rather than dropping the
       // taller-than-viewport guard. A gate that timed out never settled, so
       // don't trust its partial snapshot: fall through to the blank check.
       const painted = ready.painted > 0 || (ready.text >= TEXT_PAINTED_MIN && ready.fonts)
-      if (!ready.timedOut && painted && ready.viewport > 0 && ready.height > ready.viewport) return
+      if (
+        !ready.timedOut &&
+        painted &&
+        !ready.covered &&
+        ready.viewport > 0 &&
+        ready.height > ready.viewport
+      ) {
+        return
+      }
 
       // Otherwise fall back to the screenshot poll — re-wait while the first
       // paint is still blank — to keep the blank-SPA protection. The page has