playwright-core 1.58.0-alpha-2025-12-10 → 1.58.0-alpha-2025-12-11

package/lib/protocol/serializers.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var serializers_exports = {};
 __export(serializers_exports, {
   parseSerializedValue: () => parseSerializedValue,
+  serializePlainValue: () => serializePlainValue,
   serializeValue: () => serializeValue
 });
 module.exports = __toCommonJS(serializers_exports);
@@ -90,6 +91,9 @@ function innerParseSerializedValue(value, handles, refs, accessChain) {
 function serializeValue(value, handleSerializer) {
   return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: /* @__PURE__ */ new Map() }, []);
 }
+function serializePlainValue(arg) {
+  return serializeValue(arg, (value) => ({ fallThrough: value }));
+}
 function innerSerializeValue(value, handleSerializer, visitorInfo, accessChain) {
   const handle = handleSerializer(value);
   if ("fallThrough" in handle)
@@ -188,5 +192,6 @@ const constructorToTypedArrayKind = new Map(Object.entries(typedArrayKindToConst
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   parseSerializedValue,
+  serializePlainValue,
   serializeValue
 });

package/lib/server/agent/actionRunner.js

@@ -18,9 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var actionRunner_exports = {};
 __export(actionRunner_exports, {
-  runAction: () => runAction
+  runAction: () => runAction,
+  serializeArgument: () => serializeArgument
 });
 module.exports = __toCommonJS(actionRunner_exports);
+var import_expectUtils = require("../utils/expectUtils");
+var import_serializers = require("../../protocol/serializers");
 async function runAction(progress, page, action, secrets) {
   const frame = page.mainFrame();
   switch (action.method) {
@@ -59,10 +62,38 @@ async function runAction(progress, page, action, secrets) {
       else
         await frame.uncheck(progress, action.selector, { ...strictTrue });
       break;
+    case "expectVisible": {
+      const result = await frame.expect(progress, action.selector, { expression: "to.be.visible", isNot: false }, 5e3);
+      if (result.errorMessage)
+        throw new Error(result.errorMessage);
+      break;
+    }
+    case "expectValue": {
+      let result;
+      if (action.type === "textbox" || action.type === "combobox" || action.type === "slider") {
+        const expectedText = (0, import_expectUtils.serializeExpectedTextValues)([action.value]);
+        result = await frame.expect(progress, action.selector, { expression: "to.have.value", expectedText, isNot: false }, 5e3);
+      } else if (action.type === "checkbox" || action.type === "radio") {
+        const expectedValue = serializeArgument({ checked: true });
+        result = await frame.expect(progress, action.selector, { expression: "to.be.checked", expectedValue, isNot: false }, 5e3);
+      } else {
+        throw new Error(`Unsupported element type: ${action.type}`);
+      }
+      if (result.errorMessage)
+        throw new Error(result.errorMessage);
+      break;
+    }
   }
 }
+function serializeArgument(arg) {
+  return {
+    value: (0, import_serializers.serializePlainValue)(arg),
+    handles: []
+  };
+}
 const strictTrue = { strict: true };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runAction
+  runAction,
+  serializeArgument
 });

package/lib/server/agent/agent.js

@@ -42,9 +42,7 @@ async function pagePerform(progress, page, options) {
   const context = new import_context.Context(progress, page);
   if (await cachedPerform(context, options))
     return;
-  await perform(context, options.task, (0, import_mcpBundle.zodToJsonSchema)(import_mcpBundle.z.object({
-    error: import_mcpBundle.z.string().optional().describe("An error message if the task could not be completed successfully")
-  })), options);
+  await perform(context, options.task, void 0, options);
   await updateCache(context, options);
 }
 async function pageExtract(progress, page, options) {
@@ -70,6 +68,13 @@ async function perform(context, userTask, resultSchema, options = {}) {
     debug: import_utilsBundle.debug,
     callTool,
     tools,
+    beforeTurn: (params) => {
+      const lastReply = params.conversation.messages.findLast((m) => m.role === "assistant");
+      const toolCall = lastReply?.content.find((c) => c.type === "tool_call");
+      if (!resultSchema && toolCall && toolCall.arguments.thatShouldBeIt)
+        return "break";
+      return "continue";
+    },
     ...options
   });
   const task = `${userTask}
@@ -77,9 +82,8 @@ async function perform(context, userTask, resultSchema, options = {}) {
 ### Page snapshot
 ${full}
 `;
-  return await loop.run(task, {
-    resultSchema
-  });
+  const { result } = await loop.run(task, { resultSchema });
+  return result;
 }
 const allCaches = /* @__PURE__ */ new Map();
 async function cachedPerform(context, options) {
@@ -112,8 +116,7 @@ async function updateCache(context, options) {
 async function cachedActions(cacheFile) {
   let cache = allCaches.get(cacheFile);
   if (!cache) {
-    const text = await import_fs.default.promises.readFile(cacheFile, "utf-8").catch(() => "{}");
-    cache = JSON.parse(text);
+    cache = await import_fs.default.promises.readFile(cacheFile, "utf-8").then((text) => JSON.parse(text)).catch(() => ({}));
     allCaches.set(cacheFile, cache);
   }
   return cache;

package/lib/server/agent/context.js

@@ -34,13 +34,17 @@ class Context {
     return await this.runActionsAndWait([action]);
   }
   async runActionsAndWait(action) {
-    await this.waitForCompletion(async () => {
-      for (const a of action) {
-        await (0, import_actionRunner.runAction)(this.progress, this.page, a, this.options?.secrets ?? []);
-        this.actions.push(a);
-      }
-    });
-    return await this.snapshotResult();
+    try {
+      await this.waitForCompletion(async () => {
+        for (const a of action) {
+          await (0, import_actionRunner.runAction)(this.progress, this.page, a, this.options?.secrets ?? []);
+          this.actions.push(a);
+        }
+      });
+      return await this.snapshotResult();
+    } catch (e) {
+      return await this.snapshotResult(e);
+    }
   }
   async waitForCompletion(callback) {
     const requests = [];
@@ -73,17 +77,28 @@ class Context {
       await this.progress.wait(500);
     return result;
   }
-  async snapshotResult() {
+  async snapshotResult(error) {
     let { full } = await this.page.snapshotForAI(this.progress);
     full = this._redactText(full);
-    const text = [`# Page snapshot
-${full}`];
+    const text = [];
+    if (error)
+      text.push(`# Error
+${error.message}`);
+    else
+      text.push(`# Success`);
+    text.push(`# Page snapshot
+${full}`);
     return {
       _meta: {
         "dev.lowire/state": {
           "Page snapshot": full
-        }
+        },
+        "dev.lowire/history": error ? [{
+          category: "error",
+          content: error.message
+        }] : []
       },
+      isError: !!error,
       content: [{ type: "text", text: text.join("\n\n") }]
     };
   }

package/lib/server/agent/tools.js

@@ -22,21 +22,25 @@ __export(tools_exports, {
 });
 module.exports = __toCommonJS(tools_exports);
 var import_mcpBundle = require("../../mcpBundle");
+var import_locatorUtils = require("../../utils/isomorphic/locatorUtils");
 function defineTool(tool) {
   return tool;
 }
+const baseSchema = import_mcpBundle.z.object({
+  thatShouldBeIt: import_mcpBundle.z.boolean().describe("Indicates that this tool call is sufficient to complete the task. If false, the task will continue with the next tool call")
+});
 const snapshot = defineTool({
   schema: {
     name: "browser_snapshot",
     title: "Page snapshot",
     description: "Capture accessibility snapshot of the current page, this is better than screenshot",
-    inputSchema: import_mcpBundle.z.object({})
+    inputSchema: baseSchema
   },
   handle: async (context, params) => {
     return await context.snapshotResult();
   }
 });
-const elementSchema = import_mcpBundle.z.object({
+const elementSchema = baseSchema.extend({
   element: import_mcpBundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
   ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
 });
@@ -70,7 +74,7 @@ const drag = defineTool({
     name: "browser_drag",
     title: "Drag mouse",
     description: "Perform drag and drop between two elements",
-    inputSchema: import_mcpBundle.z.object({
+    inputSchema: baseSchema.extend({
       startElement: import_mcpBundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
       startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
       endElement: import_mcpBundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
@@ -181,7 +185,7 @@ const fillForm = defineTool({
     name: "browser_fill_form",
     title: "Fill form",
     description: "Fill multiple form fields",
-    inputSchema: import_mcpBundle.z.object({
+    inputSchema: baseSchema.extend({
       fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
         name: import_mcpBundle.z.string().describe("Human-readable field name"),
         type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
@@ -217,6 +221,61 @@ const fillForm = defineTool({
     return await context.runActionsAndWait(actions);
   }
 });
+const expectVisible = defineTool({
+  schema: {
+    name: "browser_expect_visible",
+    title: "Expect element visible",
+    description: "Expect element is visible on the page",
+    inputSchema: baseSchema.extend({
+      role: import_mcpBundle.z.string().describe('ROLE of the element. Can be found in the snapshot like this: `- {ROLE} "Accessible Name":`'),
+      accessibleName: import_mcpBundle.z.string().describe('ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: `- role "{ACCESSIBLE_NAME}"`')
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runActionAndWait({
+      method: "expectVisible",
+      selector: (0, import_locatorUtils.getByRoleSelector)(params.role, { name: params.accessibleName })
+    });
+  }
+});
+const expectVisibleText = defineTool({
+  schema: {
+    name: "browser_expect_visible_text",
+    title: "Expect text visible",
+    description: `Expect text is visible on the page. Prefer ${expectVisible.schema.name} if possible.`,
+    inputSchema: baseSchema.extend({
+      text: import_mcpBundle.z.string().describe('TEXT to expect. Can be found in the snapshot like this: `- role "Accessible Name": {TEXT}` or like this: `- text: {TEXT}`')
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runActionAndWait({
+      method: "expectVisible",
+      selector: (0, import_locatorUtils.getByTextSelector)(params.text)
+    });
+  }
+});
+const expectValue = defineTool({
+  schema: {
+    name: "browser_expect_value",
+    title: "Expect value",
+    description: "Expect element value",
+    inputSchema: baseSchema.extend({
+      type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the element"),
+      element: import_mcpBundle.z.string().describe("Human-readable element description"),
+      ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot"),
+      value: import_mcpBundle.z.string().describe('Value to expect. For checkbox, use "true" or "false".')
+    })
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([{ ref: params.ref, element: params.element }]);
+    return await context.runActionAndWait({
+      method: "expectValue",
+      selector,
+      type: params.type,
+      value: params.value
+    });
+  }
+});
 var tools_default = [
   snapshot,
   click,
@@ -225,5 +284,8 @@ var tools_default = [
   selectOption,
   pressKey,
   type,
-  fillForm
+  fillForm,
+  expectVisible,
+  expectVisibleText,
+  expectValue
 ];

package/lib/server/artifact.js

@@ -103,7 +103,7 @@ class Artifact extends import_instrumentation.SdkObject {
     if (!this._unaccessibleErrorMessage)
       await import_fs.default.promises.unlink(this._localPath).catch((e) => {
       });
-    await this.reportFinished(new import_errors.TargetClosedError());
+    await this.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
   }
   async reportFinished(error) {
     if (this._finished)

package/lib/server/chromium/crPage.js

@@ -357,9 +357,9 @@ class FrameSession {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let screencastOptions;
+    let videoOptions;
     if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
-      screencastOptions = await this._crPage._page.screencast.initializeVideoRecorder();
+      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -439,15 +439,15 @@ class FrameSession {
           true
           /* runImmediately */
         ));
-      if (screencastOptions)
-        promises.push(this._crPage._page.screencast.startVideoRecording(screencastOptions));
+      if (videoOptions)
+        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
   }
   dispose() {
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     for (const childSession of this._childSessions)
       childSession.dispose();
     if (this._parentSession)

package/lib/server/dispatchers/dispatcher.js

@@ -106,7 +106,7 @@ class Dispatcher extends import_events.EventEmitter {
     this.connection.sendEvent(this, method, params);
   }
   _dispose(reason) {
-    this._disposeRecursively(new import_errors.TargetClosedError());
+    this._disposeRecursively(new import_errors.TargetClosedError(this._object.closeReason()));
     this.connection.sendDispose(this, reason);
   }
   _onDispose() {
@@ -257,7 +257,7 @@ class DispatcherConnection {
     const { id, guid, method, params, metadata } = message;
     const dispatcher = this._dispatcherByGuid.get(guid);
     if (!dispatcher) {
-      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError()) });
+      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError(void 0)) });
       return;
     }
     let validParams;
@@ -325,19 +325,19 @@ class DispatcherConnection {
     const response = { id };
     try {
       if (this._dispatcherByGuid.get(guid) !== dispatcher)
-        throw new import_errors.TargetClosedError(closeReason(sdkObject));
+        throw new import_errors.TargetClosedError(sdkObject.closeReason());
       const result = await dispatcher._runCommand(callMetadata, method, validParams);
       const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Result");
       response.result = validator(result, "", this._validatorToWireContext());
       callMetadata.result = result;
     } catch (e) {
       if ((0, import_errors.isTargetClosedError)(e)) {
-        const reason = closeReason(sdkObject);
+        const reason = sdkObject.closeReason();
         if (reason)
           (0, import_utils.rewriteErrorMessage)(e, reason);
       } else if ((0, import_protocolError.isProtocolError)(e)) {
         if (e.type === "closed")
-          e = new import_errors.TargetClosedError(closeReason(sdkObject), e.browserLogMessage());
+          e = new import_errors.TargetClosedError(sdkObject.closeReason(), e.browserLogMessage());
         else if (e.type === "crashed")
           (0, import_utils.rewriteErrorMessage)(e, "Target crashed " + e.browserLogMessage());
       }
@@ -359,9 +359,6 @@ class DispatcherConnection {
       await new Promise((f) => setTimeout(f, slowMo));
   }
 }
-function closeReason(sdkObject) {
-  return sdkObject.attribution.page?.closeReason || sdkObject.attribution.context?._closeReason || sdkObject.attribution.browser?._closeReason;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Dispatcher,

package/lib/server/firefox/ffBrowser.js

@@ -146,7 +146,7 @@ class FFBrowser extends import_browser.Browser {
   }
   _onDisconnect() {
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     for (const ffPage of this._ffPages.values())
       ffPage.didClose();

package/lib/server/firefox/ffPage.js

@@ -276,7 +276,7 @@ class FFPage {
     this._browserContext._browser._videoStarted(this._browserContext, event.screencastId, event.file, this._page.waitForInitializedOrError());
   }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError());
+    this._markAsError(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();

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/page.js

@@ -163,7 +163,7 @@ class Page extends import_instrumentation.SdkObject {
     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();
@@ -577,7 +577,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)

package/lib/server/progress.js

@@ -68,6 +68,8 @@ class ProgressController {
     if (timeout) {
       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 };

package/lib/server/screencast.js

@@ -40,11 +40,12 @@ var import_registry = require("./registry");
 class Screencast {
   constructor(page) {
     this._videoRecorder = null;
-    this._screencastId = null;
+    this._videoId = null;
     this._screencastClients = /* @__PURE__ */ new Set();
     // 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._frameListener = null;
     this._page = page;
   }
   stopFrameThrottler() {
@@ -60,29 +61,31 @@ class Screencast {
   temporarilyDisableThrottling() {
     this._frameThrottler.recharge();
   }
-  async initializeVideoRecorder() {
+  launchVideoRecorder() {
     const recordVideo = this._page.browserContext._options.recordVideo;
     if (!recordVideo)
       return void 0;
-    const screencastId = (0, import_utils.createGuid)();
-    const outputFile = import_path.default.join(recordVideo.dir, screencastId + ".webm");
-    const screencastOptions = {
+    (0, import_utils.assert)(!this._videoId);
+    this._videoId = (0, import_utils.createGuid)();
+    const outputFile = import_path.default.join(recordVideo.dir, this._videoId + ".webm");
+    const videoOptions = {
       // validateBrowserContextOptions ensures correct video size.
       ...recordVideo.size,
       outputFile
     };
-    await (0, import_utils.mkdirIfNeeded)(import_path.default.join(recordVideo.dir, "dummy"));
-    await this._createVideoRecorder(screencastId, screencastOptions);
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
+    this._videoRecorder = new import_videoRecorder.VideoRecorder(ffmpegPath, videoOptions);
+    this._frameListener = import_utils.eventsHelper.addEventListener(this._page, import_page.Page.Events.ScreencastFrame, (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
     this._page.waitForInitializedOrError().then((p) => {
       if (p instanceof Error)
         this.stopVideoRecording().catch(() => {
         });
     });
-    return screencastOptions;
+    return videoOptions;
   }
   async startVideoRecording(options) {
-    const screencastId = this._screencastId;
-    (0, import_utils.assert)(screencastId);
+    const videoId = this._videoId;
+    (0, import_utils.assert)(videoId);
     this._page.once(import_page.Page.Events.Close, () => this.stopVideoRecording().catch(() => {
     }));
     const gotFirstFrame = new Promise((f) => this._page.once(import_page.Page.Events.ScreencastFrame, f));
@@ -92,20 +95,22 @@ class Screencast {
       height: options.height
     });
     gotFirstFrame.then(() => {
-      this._page.browserContext._browser._videoStarted(this._page.browserContext, screencastId, options.outputFile, this._page.waitForInitializedOrError());
+      this._page.browserContext._browser._videoStarted(this._page.browserContext, videoId, options.outputFile, this._page.waitForInitializedOrError());
     });
   }
   async stopVideoRecording() {
-    if (!this._screencastId)
+    if (!this._videoId)
       return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
+    if (this._frameListener)
+      import_utils.eventsHelper.removeEventListeners([this._frameListener]);
+    this._frameListener = null;
+    const videoId = this._videoId;
+    this._videoId = null;
+    const videoRecorder = this._videoRecorder;
     this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._page.browserContext._browser._takeVideo(screencastId);
+    await this._stopScreencast(videoRecorder);
+    await videoRecorder.stop();
+    const video = this._page.browserContext._browser._takeVideo(videoId);
     video?.reportFinished();
   }
   async _setOptions(options) {
@@ -129,12 +134,6 @@ class Screencast {
     if (!this._screencastClients.size)
       await this._page.delegate.stopScreencast();
   }
-  async _createVideoRecorder(screencastId, options) {
-    (0, import_utils.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._page, ffmpegPath, options);
-    this._screencastId = screencastId;
-  }
 }
 class FrameThrottler {
   constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {

package/lib/server/videoRecorder.js

@@ -22,11 +22,10 @@ __export(videoRecorder_exports, {
 });
 module.exports = __toCommonJS(videoRecorder_exports);
 var import_utils = require("../utils");
-var import_page = require("./page");
 var import_processLauncher = require("./utils/processLauncher");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath) {
+  constructor(ffmpegPath, options) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -36,16 +35,12 @@ class VideoRecorder {
     this._frameQueue = [];
     this._isStopped = false;
     this._ffmpegPath = ffmpegPath;
-    page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-  }
-  static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const recorder = new VideoRecorder(page, ffmpegPath);
-    await recorder._launch(options);
-    return recorder;
+    this._launchPromise = this._launch(options).catch((e) => e);
   }
   async _launch(options) {
+    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
@@ -74,6 +69,13 @@ class VideoRecorder {
     this._gracefullyClose = gracefullyClose;
   }
   writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
     (0, import_utils.assert)(this._process);
     if (this._isStopped)
       return;
@@ -100,13 +102,20 @@ class VideoRecorder {
     });
   }
   async stop() {
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
     if (this._isStopped || !this._lastFrame)
       return;
     const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
-    this.writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
+    this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
-    await this._lastWritePromise;
-    await this._gracefullyClose();
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/wkBrowser.js

@@ -79,7 +79,7 @@ class WKBrowser extends import_browser.Browser {
       wkPage.didClose();
     this._wkPages.clear();
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     this._didClose();
   }