patchright-core 1.57.0 → 1.58.2

package/lib/server/instrumentation.js

@@ -33,6 +33,9 @@ class SdkObject extends import_events.EventEmitter {
     this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
+  closeReason() {
+    return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
+  }
 }
 function createRootSdkObject() {
   const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };

package/lib/server/javascript.js

@@ -118,10 +118,12 @@ class JSHandle extends import_instrumentation.SdkObject {
     if (context.constructor.name === "FrameExecutionContext") {
       const frame = context.frame;
       if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: true }, this, arg);
     await context.doSlowMo();
     return value;
@@ -131,10 +133,12 @@ class JSHandle extends import_instrumentation.SdkObject {
     if (context.constructor.name === "FrameExecutionContext") {
       const frame = this._context.frame;
       if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: false }, this, arg);
     await context.doSlowMo();
     return value;

package/lib/server/launchApp.js

@@ -114,7 +114,8 @@ async function syncLocalStorageWithSettings(page, appName) {
           return;
         Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
         window.saveSettings = () => {
-          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+          if (typeof window._saveSerializedSettings === "function")
+            window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
         };
       })})(${settings});
     `

package/lib/server/network.js

@@ -22,6 +22,7 @@ __export(network_exports, {
   Response: () => Response,
   Route: () => Route,
   WebSocket: () => WebSocket,
+  applyHeadersOverrides: () => applyHeadersOverrides,
   filterCookies: () => filterCookies,
   isLocalHostname: () => isLocalHostname,
   kMaxCookieExpiresDateInSeconds: () => kMaxCookieExpiresDateInSeconds,
@@ -61,6 +62,48 @@ function filterCookies(cookies, urls) {
 function isLocalHostname(hostname) {
   return hostname === "localhost" || hostname.endsWith(".localhost");
 }
+const FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "set-cookie",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+const FORBIDDEN_METHODS = /* @__PURE__ */ new Set(["CONNECT", "TRACE", "TRACK"]);
+function isForbiddenHeader(name, value) {
+  const lowerName = name.toLowerCase();
+  if (FORBIDDEN_HEADER_NAMES.has(lowerName))
+    return true;
+  if (lowerName.startsWith("proxy-"))
+    return true;
+  if (lowerName.startsWith("sec-"))
+    return true;
+  if (lowerName === "x-http-method" || lowerName === "x-http-method-override" || lowerName === "x-method-override") {
+    if (value && FORBIDDEN_METHODS.has(value.toUpperCase()))
+      return true;
+  }
+  return false;
+}
+function applyHeadersOverrides(original, overrides) {
+  const forbiddenHeaders = original.filter((header) => isForbiddenHeader(header.name, header.value));
+  const allowedHeaders = overrides.filter((header) => !isForbiddenHeader(header.name, header.value));
+  return mergeHeaders([allowedHeaders, forbiddenHeaders]);
+}
 const kMaxCookieExpiresDateInSeconds = 253402300799;
 function rewriteCookies(cookies) {
   return cookies.map((c) => {
@@ -99,7 +142,6 @@ class Request extends import_instrumentation.SdkObject {
     this._response = null;
     this._redirectedTo = null;
     this._failureText = null;
-    this._headersMap = /* @__PURE__ */ new Map();
     this._frame = null;
     this._serviceWorker = null;
     this._rawRequestHeadersPromise = new import_manualPromise.ManualPromise();
@@ -118,7 +160,6 @@ class Request extends import_instrumentation.SdkObject {
     this._method = method;
     this._postData = postData;
     this._headers = headers;
-    this._updateHeadersMap();
     this._isFavicon = url.endsWith("/favicon.ico") || !!redirectedFrom?._isFavicon;
   }
   static {
@@ -132,13 +173,8 @@ class Request extends import_instrumentation.SdkObject {
   }
   _applyOverrides(overrides) {
     this._overrides = { ...this._overrides, ...overrides };
-    this._updateHeadersMap();
     return this._overrides;
   }
-  _updateHeadersMap() {
-    for (const { name, value } of this.headers())
-      this._headersMap.set(name.toLowerCase(), value);
-  }
   overrides() {
     return this._overrides;
   }
@@ -158,7 +194,8 @@ class Request extends import_instrumentation.SdkObject {
     return this._overrides?.headers || this._headers;
   }
   headerValue(name) {
-    return this._headersMap.get(name);
+    const lowerCaseName = name.toLowerCase();
+    return this.headers().find((h) => h.name.toLowerCase() === lowerCaseName)?.value;
   }
   // "null" means no raw headers available - we'll use provisional headers as raw headers.
   setRawRequestHeaders(headers) {
@@ -309,10 +346,7 @@ class Route extends import_instrumentation.SdkObject {
         throw new Error("New URL must have same protocol as overridden URL");
     }
     if (overrides.headers) {
-      overrides.headers = overrides.headers?.filter((header) => {
-        const headerName = header.name.toLowerCase();
-        return headerName !== "cookie" && headerName !== "host";
-      });
+      overrides.headers = applyHeadersOverrides(this._request._headers, overrides.headers);
     }
     overrides = this._request._applyOverrides(overrides);
     const nextHandler = this._futureHandlers.shift();
@@ -436,6 +470,9 @@ class Response extends import_instrumentation.SdkObject {
   request() {
     return this._request;
   }
+  finished() {
+    return this._finishedPromise;
+  }
   frame() {
     return this._request.frame();
   }
@@ -617,6 +654,7 @@ function mergeHeaders(headers) {
   Response,
   Route,
   WebSocket,
+  applyHeadersOverrides,
   filterCookies,
   isLocalHostname,
   kMaxCookieExpiresDateInSeconds,

package/lib/server/page.js

@@ -31,7 +31,8 @@ __export(page_exports, {
   InitScript: () => InitScript,
   Page: () => Page,
   PageBinding: () => PageBinding,
-  Worker: () => Worker
+  Worker: () => Worker,
+  WorkerEvent: () => WorkerEvent
 });
 module.exports = __toCommonJS(page_exports);
 var import_pageBinding = require("./pageBinding");
@@ -53,6 +54,22 @@ var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
+var import_screencast = require("./screencast");
+const PageEvent = {
+  Close: "close",
+  Crash: "crash",
+  Download: "download",
+  EmulatedSizeChanged: "emulatedsizechanged",
+  FileChooser: "filechooser",
+  FrameAttached: "frameattached",
+  FrameDetached: "framedetached",
+  InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
+  LocatorHandlerTriggered: "locatorhandlertriggered",
+  ScreencastFrame: "screencastframe",
+  Video: "video",
+  WebSocket: "websocket",
+  Worker: "worker"
+};
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -74,9 +91,6 @@ class Page extends import_instrumentation.SdkObject {
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
     this._networkRequests = [];
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
     this.attribution.page = this;
     this.delegate = delegate;
     this.browserContext = browserContext;
@@ -85,27 +99,14 @@ class Page extends import_instrumentation.SdkObject {
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
     this.frameManager = new frames.FrameManager(this);
+    this.screencast = new import_screencast.Screencast(this);
     if (delegate.pdf)
       this.pdf = delegate.pdf.bind(delegate);
     this.coverage = delegate.coverage ? delegate.coverage() : null;
     this.isStorageStatePage = browserContext.isCreatingStorageStatePage();
   }
   static {
-    this.Events = {
-      Close: "close",
-      Crash: "crash",
-      Download: "download",
-      EmulatedSizeChanged: "emulatedsizechanged",
-      FileChooser: "filechooser",
-      FrameAttached: "frameattached",
-      FrameDetached: "framedetached",
-      InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
-      LocatorHandlerTriggered: "locatorhandlertriggered",
-      ScreencastFrame: "screencastframe",
-      Video: "video",
-      WebSocket: "websocket",
-      Worker: "worker"
-    };
+    this.Events = PageEvent;
   }
   async reportAsNew(opener, error) {
     if (opener) {
@@ -158,17 +159,17 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didClose() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.stopFrameThrottler();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
     this.emit(Page.Events.Close);
     this._closedPromise.resolve();
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new import_errors.TargetClosedError());
+    this.openScope.close(new import_errors.TargetClosedError(this.closeReason()));
   }
   _didCrash() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.stopFrameThrottler();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
@@ -567,7 +568,7 @@ class Page extends import_instrumentation.SdkObject {
     if (this._closedState === "closed")
       return;
     if (options.reason)
-      this.closeReason = options.reason;
+      this._closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
     if (this._closedState !== "closing") {
       if (!runBeforeUnload)
@@ -624,16 +625,6 @@ class Page extends import_instrumentation.SdkObject {
   getBinding(name) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
-  setScreencastOptions(options) {
-    this.delegate.setScreencastOptions(options).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
-  }
-  throttleScreencastFrameAck(ack) {
-    this._frameThrottler.ack(ack);
-  }
-  temporarilyDisableTracingScreencastThrottling() {
-    this._frameThrottler.recharge();
-  }
   async safeNonStallingEvaluateInAllFrames(expression, world, options = {}) {
     await Promise.all(this.frames().map(async (frame) => {
       try {
@@ -648,7 +639,7 @@ class Page extends import_instrumentation.SdkObject {
     await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
     })));
   }
-  async snapshotForAI(progress, options) {
+  async snapshotForAI(progress, options = {}) {
     const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), options);
     return { full: snapshot.full.join("\n"), incremental: snapshot.incremental?.join("\n") };
   }
@@ -656,6 +647,9 @@ class Page extends import_instrumentation.SdkObject {
     return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
   }
 }
+const WorkerEvent = {
+  Close: "close"
+};
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
     super(parent, "worker");
@@ -666,9 +660,7 @@ class Worker extends import_instrumentation.SdkObject {
     this.url = url;
   }
   static {
-    this.Events = {
-      Close: "close"
-    };
+    this.Events = WorkerEvent;
   }
   createExecutionContext(delegate) {
     this.existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
@@ -719,6 +711,32 @@ class PageBinding {
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
+    const deliver = async (deliverPayload) => {
+      let deliveryError;
+      try {
+        await context.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+        return;
+      } catch (e) {
+        deliveryError = e;
+      }
+      const frame = context.frame;
+      if (!frame) {
+        import_debugLogger.debugLogger.log("error", deliveryError);
+        return;
+      }
+      const mainContext = await frame._mainContext().catch(() => null);
+      const utilityContext = await frame._utilityContext().catch(() => null);
+      for (const ctx of [mainContext, utilityContext]) {
+        if (!ctx || ctx === context)
+          continue;
+        try {
+          await ctx.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+          return;
+        } catch {
+        }
+      }
+      import_debugLogger.debugLogger.log("error", deliveryError);
+    };
     try {
       (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
@@ -734,9 +752,9 @@ class PageBinding {
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
         result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
       }
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      await deliver({ name, seq, result });
     } catch (error) {
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      await deliver({ name, seq, error });
     }
   }
 }
@@ -745,56 +763,7 @@ class InitScript {
     this.source = `(() => { ${source} })();`;
   }
 }
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._throttlingEnabled = false;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
-  }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = void 0;
-    }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    for (const ack of this._acks)
-      ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
-    }
-  }
-  ack(ack) {
-    if (!this._timeoutId) {
-      ack();
-      return;
-    }
-    this._acks.push(ack);
-  }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
-  }
-}
-async function snapshotFrameForAI(progress, frame, options) {
+async function snapshotFrameForAI(progress, frame, options = {}) {
   const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
     try {
       const context = await progress.race(frame._utilityContext());
@@ -804,7 +773,7 @@ async function snapshotFrameForAI(progress, frame, options) {
         if (!node)
           return true;
         return injected.incrementalAriaSnapshot(node, { mode: "ai", ...options2 });
-      }, { refPrefix: frame.seq ? "f" + frame.seq : "", track: options.track }));
+      }, { refPrefix: frame.seq ? "f" + frame.seq : "", track: options.track, doNotRenderActive: options.doNotRenderActive }));
       if (snapshotOrRetry === true)
         return continuePolling;
       return snapshotOrRetry;
@@ -864,5 +833,6 @@ function ensureArrayLimit(array, limit) {
   InitScript,
   Page,
   PageBinding,
-  Worker
+  Worker,
+  WorkerEvent
 });

package/lib/server/progress.js

@@ -34,19 +34,35 @@ class ProgressController {
     this.metadata = metadata || { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
     this._onCallLog = onCallLog;
     this._forceAbortPromise.catch((e) => null);
+    this._controller = new AbortController();
+  }
+  static createForSdkObject(sdkObject, callMetadata) {
+    const logName = sdkObject.logName || "api";
+    return new ProgressController(callMetadata, (message) => {
+      import_utils.debugLogger.log(logName, message);
+      sdkObject.instrumentation.onCallLog(sdkObject, callMetadata, logName, message);
+    });
   }
   async abort(error) {
     if (this._state === "running") {
       error[kAbortErrorSymbol] = true;
       this._state = { error };
       this._forceAbortPromise.reject(error);
+      this._controller.abort(error);
     }
     await this._donePromise;
   }
   async run(task, timeout) {
+    const deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
+    let timer;
     const progress = {
+      timeout: timeout ?? 0,
+      deadline,
+      disableTimeout: () => {
+        clearTimeout(timer);
+      },
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
@@ -55,24 +71,28 @@ class ProgressController {
       metadata: this.metadata,
       race: (promise) => {
         const promises = Array.isArray(promise) ? promise : [promise];
+        if (!promises.length)
+          return Promise.resolve();
         return Promise.race([...promises, this._forceAbortPromise]);
       },
       wait: async (timeout2) => {
         let timer2;
         const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
         return progress.race(promise).finally(() => clearTimeout(timer2));
-      }
+      },
+      signal: this._controller.signal
     };
-    let timer;
-    if (timeout) {
+    if (deadline) {
       const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
       timer = setTimeout(() => {
+        if (this.metadata.pauseStartTime && !this.metadata.pauseEndTime)
+          return;
         if (this._state === "running") {
-          timeoutError[kAbortErrorSymbol] = true;
           this._state = { error: timeoutError };
           this._forceAbortPromise.reject(timeoutError);
+          this._controller.abort(timeoutError);
         }
-      }, timeout);
+      }, deadline - (0, import_utils.monotonicTime)());
     }
     try {
       const result = await task(progress);
@@ -89,7 +109,7 @@ class ProgressController {
 }
 const kAbortErrorSymbol = Symbol("kAbortError");
 function isAbortError(error) {
-  return !!error[kAbortErrorSymbol];
+  return error instanceof import_errors.TimeoutError || !!error[kAbortErrorSymbol];
 }
 async function raceUncancellableOperationWithCleanup(progress, run, cleanup) {
   let aborted = false;