diff --git a/CLAUDE.md b/CLAUDE.md
index d168ae9d1b9fc..858166243e0f6 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -122,6 +122,7 @@ EOF
 )"
 ```
 
+Never add Co-Authored-By agents in commit message.
 Branch naming for issue fixes: `fix-<issue-number>`
 
 ## Development Guides
diff --git a/docs/src/api/class-inspector.md b/docs/src/api/class-inspector.md
deleted file mode 100644
index 67789d029bd33..0000000000000
--- a/docs/src/api/class-inspector.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# class: Inspector
-* since: v1.59
-* langs: js
-
-Interface to the Playwright inspector.
-
-## async method: Inspector.cancelPickLocator
-* since: v1.59
-
-Cancels an ongoing [`method: Inspector.pickLocator`] call by deactivating pick locator mode.
-If no pick locator mode is active, this method is a no-op.
-
-## async method: Inspector.pickLocator
-* since: v1.59
-- returns: <[Locator]>
-
-Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
-Once the user clicks an element, the mode is deactivated and the [Locator] for the picked element is returned.
-
-**Usage**
-
-```js
-const locator = await page.inspector().pickLocator();
-console.log(locator);
-```
-
-## event: Inspector.screencastFrame
-* since: v1.59
-- argument: <[Object]>
-  - `data` <[Buffer]> JPEG-encoded frame data.
-
-Emitted for each captured JPEG screencast frame while the screencast is running.
-
-**Usage**
-
-```js
-const inspector = page.inspector();
-inspector.on('screencastframe', ({ data, width, height }) => {
-  console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-  require('fs').writeFileSync('frame.jpg', data);
-});
-await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-// ... perform actions ...
-await inspector.stopScreencast();
-```
-
-## async method: Inspector.startScreencast
-* since: v1.59
-
-Starts capturing screencast frames. Frames are emitted as [`event: Inspector.screencastFrame`] events.
-
-**Usage**
-
-```js
-const inspector = page.inspector();
-inspector.on('screencastframe', ({ data, width, height }) => {
-  console.log(`frame ${width}x${height}, size: ${data.length}`);
-});
-await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
-// ... perform actions ...
-await inspector.stopScreencast();
-```
-
-### option: Inspector.startScreencast.maxSize
-* since: v1.59
-- `maxSize` ?<[Object]>
-  - `width` <[int]> Max frame width in pixels.
-  - `height` <[int]> Max frame height in pixels.
-
-Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to 800×800.
-
-## async method: Inspector.stopScreencast
-* since: v1.59
-
-Stops the screencast started with [`method: Inspector.startScreencast`].
-
-**Usage**
-
-```js
-await inspector.startScreencast();
-// ... perform actions ...
-await inspector.stopScreencast();
-```
diff --git a/docs/src/api/class-page.md b/docs/src/api/class-page.md
index 1b3093a52ebc8..0300069b02d49 100644
--- a/docs/src/api/class-page.md
+++ b/docs/src/api/class-page.md
@@ -763,6 +763,13 @@ System prompt for the agent's loop.
 
 Brings page to front (activates tab).
 
+## async method: Page.cancelPickLocator
+* since: v1.59
+* langs: js
+
+Cancels an ongoing [`method: Page.pickLocator`] call by deactivating pick locator mode.
+If no pick locator mode is active, this method is a no-op.
+
 ## async method: Page.check
 * since: v1.8
 * discouraged: Use locator-based [`method: Locator.check`] instead. Read more about [locators](../locators.md).
@@ -2600,25 +2607,6 @@ Throws for non-input elements. However, if the element is inside the `<label>` e
 ### option: Page.inputValue.timeout = %%-input-timeout-js-%%
 * since: v1.13
 
-## method: Page.inspector
-* since: v1.59
-* langs: js
-- returns: <[Inspector]>
-
-Returns the [Inspector] object associated with this page.
-
-**Usage**
-
-```js
-const inspector = page.inspector();
-inspector.on('screencastFrame', data => {
-  console.log('received frame, jpeg size:', data.length);
-});
-await inspector.startScreencast();
-// ... perform actions ...
-await inspector.stopScreencast();
-```
-
 ## async method: Page.isChecked
 * since: v1.8
 * discouraged: Use locator-based [`method: Locator.isChecked`] instead. Read more about [locators](../locators.md).
@@ -3077,6 +3065,20 @@ Whether or not to generate tagged (accessible) PDF. Defaults to `false`.
 
 Whether or not to embed the document outline into the PDF. Defaults to `false`.
 
+## async method: Page.pickLocator
+* since: v1.59
+* langs: js
+- returns: <[Locator]>
+
+Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+Once the user clicks an element, the mode is deactivated and the [Locator] for the picked element is returned.
+
+**Usage**
+
+```js
+const locator = await page.pickLocator();
+console.log(locator);
+```
 
 ## async method: Page.press
 * since: v1.8
@@ -3886,6 +3888,26 @@ Handler function to route the WebSocket.
 Handler function to route the WebSocket.
 
 
+## method: Page.screencast
+* since: v1.59
+* langs: js
+- returns: <[Screencast]>
+
+Returns the [Screencast] object associated with this page.
+
+**Usage**
+
+```js
+const screencast = page.screencast();
+screencast.on('screencastFrame', data => {
+  console.log('received frame, jpeg size:', data.length);
+});
+await screencast.start();
+// ... perform actions ...
+await screencast.stop();
+```
+
+
 ## async method: Page.screenshot
 * since: v1.8
 - returns: <[Buffer]>
diff --git a/docs/src/api/class-screencast.md b/docs/src/api/class-screencast.md
new file mode 100644
index 0000000000000..b013d1e54ac8d
--- /dev/null
+++ b/docs/src/api/class-screencast.md
@@ -0,0 +1,63 @@
+# class: Screencast
+* since: v1.59
+* langs: js
+
+Interface for capturing screencast frames from a page.
+
+## event: Screencast.screencastFrame
+* since: v1.59
+- argument: <[Object]>
+  - `data` <[Buffer]> JPEG-encoded frame data.
+
+Emitted for each captured JPEG screencast frame while the screencast is running.
+
+**Usage**
+
+```js
+const screencast = page.screencast();
+screencast.on('screencastframe', ({ data, width, height }) => {
+  console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+  require('fs').writeFileSync('frame.jpg', data);
+});
+await screencast.start({ maxSize: { width: 1200, height: 800 } });
+// ... perform actions ...
+await screencast.stop();
+```
+
+## async method: Screencast.start
+* since: v1.59
+
+Starts capturing screencast frames. Frames are emitted as [`event: Screencast.screencastFrame`] events.
+
+**Usage**
+
+```js
+const screencast = page.screencast();
+screencast.on('screencastframe', ({ data, width, height }) => {
+  console.log(`frame ${width}x${height}, size: ${data.length}`);
+});
+await screencast.start({ maxSize: { width: 800, height: 600 } });
+// ... perform actions ...
+await screencast.stop();
+```
+
+### option: Screencast.start.maxSize
+* since: v1.59
+- `maxSize` ?<[Object]>
+  - `width` <[int]> Max frame width in pixels.
+  - `height` <[int]> Max frame height in pixels.
+
+Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to 800×800.
+
+## async method: Screencast.stop
+* since: v1.59
+
+Stops the screencast started with [`method: Screencast.start`].
+
+**Usage**
+
+```js
+await screencast.start();
+// ... perform actions ...
+await screencast.stop();
+```
diff --git a/docs/src/chrome-extensions-js-python.md b/docs/src/chrome-extensions-js-python.md
index 9512a0acf876c..1475ffb22f3e3 100644
--- a/docs/src/chrome-extensions-js-python.md
+++ b/docs/src/chrome-extensions-js-python.md
@@ -101,6 +101,45 @@ with sync_playwright() as playwright:
     run(playwright)
 ```
 
+## Service worker idle suspension (MV3)
+
+Chrome MV3 service workers are automatically suspended after ~30 seconds of inactivity and restarted
+on demand. When this happens, Playwright keeps the **same [Worker] object alive** — no new
+`'serviceworker'` event is emitted. New `evaluate()` calls issued during the restart window are
+stalled until the new context is ready and then resume automatically:
+
+```js
+const sw = await context.waitForEvent('serviceworker');
+
+// ... SW suspends after 30 s of inactivity and is restarted by the browser ...
+
+// The existing handle is transparent across the restart.
+await sw.evaluate(() => sendMessage({ type: 'ping' })); // just works
+```
+
+```python async
+sw = await context.wait_for_event('serviceworker')
+
+# ... SW suspends after 30 s of inactivity and is restarted by the browser ...
+
+# The existing handle is transparent across the restart.
+await sw.evaluate("sendMessage({ type: 'ping' })")  # just works
+```
+
+```python sync
+sw = context.wait_for_event('serviceworker')
+
+# ... SW suspends after 30 s of inactivity and is restarted by the browser ...
+
+# The existing handle is transparent across the restart.
+sw.evaluate("sendMessage({ type: 'ping' })")  # just works
+```
+
+:::note
+`evaluate()` calls that were already in-flight at the exact moment of suspension will throw
+with `"Service worker restarted"`, matching the behaviour of page navigations mid-flight.
+:::
+
 ## Testing
 
 To have the extension loaded when running tests you can use a test fixture to set the context. You can also dynamically retrieve the extension id and use it to load and test the popup page for example.
diff --git a/packages/devtools/src/grid.tsx b/packages/devtools/src/grid.tsx
index de27e32e25a20..fc5d4a7346e0b 100644
--- a/packages/devtools/src/grid.tsx
+++ b/packages/devtools/src/grid.tsx
@@ -44,7 +44,7 @@ export const Grid: React.FC<{ model: SessionModel }> = ({ model }) => {
   const workspaceGroups = React.useMemo(() => {
     const groups = new Map<string, SessionStatus[]>();
     for (const session of sessions) {
-      const key = session.browserDescriptor.workspaceDir || 'Global';
+      const key = session.workspaceDir || 'Global';
       let list = groups.get(key);
       if (!list) {
         list = [];
@@ -53,7 +53,7 @@ export const Grid: React.FC<{ model: SessionModel }> = ({ model }) => {
       list.push(session);
     }
     for (const list of groups.values())
-      list.sort((a, b) => a.browserDescriptor.title.localeCompare(b.browserDescriptor.title));
+      list.sort((a, b) => a.title.localeCompare(b.title));
 
     // Current workspace first, then alphabetical.
     const entries = [...groups.entries()];
@@ -91,7 +91,7 @@ export const Grid: React.FC<{ model: SessionModel }> = ({ model }) => {
               </div>
               {isExpanded && (
                 <div className='session-chips'>
-                  {entries.map(session => <SessionChip key={session.browserDescriptor.guid} descriptor={session.browserDescriptor} wsUrl={session.wsUrl} visible={isExpanded} model={model} />)}
+                  {entries.map(session => <SessionChip key={session.browser.guid} descriptor={session} wsUrl={session.wsUrl} visible={isExpanded} model={model} />)}
                 </div>
               )}
             </div>
@@ -103,7 +103,7 @@ export const Grid: React.FC<{ model: SessionModel }> = ({ model }) => {
 };
 
 const SessionChip: React.FC<{ descriptor: BrowserDescriptor; wsUrl: string | undefined; visible: boolean; model: SessionModel }> = ({ descriptor, wsUrl, visible, model }) => {
-  const href = '#session=' + encodeURIComponent(descriptor.guid);
+  const href = '#session=' + encodeURIComponent(descriptor.browser.guid);
 
   const channel = React.useMemo(() => {
     if (!wsUrl || !visible)
diff --git a/packages/devtools/src/sessionModel.ts b/packages/devtools/src/sessionModel.ts
index 869e378938352..74526f9e58cc8 100644
--- a/packages/devtools/src/sessionModel.ts
+++ b/packages/devtools/src/sessionModel.ts
@@ -17,12 +17,10 @@
 import type { ClientInfo } from '../../playwright-core/src/cli/client/registry';
 import type { BrowserDescriptor } from '../../playwright-core/src/serverRegistry';
 
-export type SessionStatus = {
-  browserDescriptor: BrowserDescriptor;
+export type SessionStatus = BrowserDescriptor & {
   wsUrl?: string;
 };
 
-
 type Listener = () => void;
 
 export class SessionModel {
@@ -67,7 +65,7 @@ export class SessionModel {
   }
 
   sessionByGuid(guid: string): SessionStatus | undefined {
-    return this.sessions.find(s => s.browserDescriptor.guid === guid);
+    return this.sessions.find(s => s.browser.guid === guid);
   }
 
   private async _fetchSessions() {
@@ -103,7 +101,7 @@ export class SessionModel {
     await fetch('/api/sessions/close', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sessionGuid: descriptor.guid }),
+      body: JSON.stringify({ guid: descriptor.browser.guid }),
     });
     await this._fetchSessions();
   }
@@ -112,7 +110,7 @@ export class SessionModel {
     await fetch('/api/sessions/delete-data', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sessionGuid: descriptor.guid }),
+      body: JSON.stringify({ guid: descriptor.browser.guid }),
     });
     await this._fetchSessions();
   }
diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.ts
index c7b0375a83056..94a3e2df326ff 100644
--- a/packages/playwright-client/types/types.d.ts
+++ b/packages/playwright-client/types/types.d.ts
@@ -2187,6 +2187,12 @@ export interface Page {
    */
   bringToFront(): Promise<void>;
 
+  /**
+   * Cancels an ongoing [page.pickLocator()](https://playwright.dev/docs/api/class-page#page-pick-locator) call by
+   * deactivating pick locator mode. If no pick locator mode is active, this method is a no-op.
+   */
+  cancelPickLocator(): Promise<void>;
+
   /**
    * **NOTE** Use locator-based [locator.check([options])](https://playwright.dev/docs/api/class-locator#locator-check) instead.
    * Read more about [locators](https://playwright.dev/docs/locators).
@@ -3502,24 +3508,6 @@ export interface Page {
     timeout?: number;
   }): Promise<string>;
 
-  /**
-   * Returns the [Inspector](https://playwright.dev/docs/api/class-inspector) object associated with this page.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastFrame', data => {
-   *   console.log('received frame, jpeg size:', data.length);
-   * });
-   * await inspector.startScreencast();
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  inspector(): Inspector;
-
   /**
    * **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)
    * instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -3922,6 +3910,21 @@ export interface Page {
     width?: string|number;
   }): Promise<Buffer>;
 
+  /**
+   * Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+   * Once the user clicks an element, the mode is deactivated and the
+   * [Locator](https://playwright.dev/docs/api/class-locator) for the picked element is returned.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const locator = await page.pickLocator();
+   * console.log(locator);
+   * ```
+   *
+   */
+  pickLocator(): Promise<Locator>;
+
   /**
    * **NOTE** Use locator-based [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press)
    * instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -4225,6 +4228,24 @@ export interface Page {
    */
   routeWebSocket(url: string|RegExp|URLPattern|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;
 
+  /**
+   * Returns the [Screencast](https://playwright.dev/docs/api/class-screencast) object associated with this page.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastFrame', data => {
+   *   console.log('received frame, jpeg size:', data.length);
+   * });
+   * await screencast.start();
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  screencast(): Screencast;
+
   /**
    * Returns the buffer with the captured screenshot.
    * @param options
@@ -20580,187 +20601,6 @@ export interface FrameLocator {
   owner(): Locator;
 }
 
-/**
- * Interface to the Playwright inspector.
- */
-export interface Inspector {
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  on(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
-   */
-  once(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  addListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Removes an event listener added by `on` or `addListener`.
-   */
-  removeListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Removes an event listener added by `on` or `addListener`.
-   */
-  off(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  prependListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Cancels an ongoing
-   * [inspector.pickLocator()](https://playwright.dev/docs/api/class-inspector#inspector-pick-locator) call by
-   * deactivating pick locator mode. If no pick locator mode is active, this method is a no-op.
-   */
-  cancelPickLocator(): Promise<void>;
-
-  /**
-   * Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
-   * Once the user clicks an element, the mode is deactivated and the
-   * [Locator](https://playwright.dev/docs/api/class-locator) for the picked element is returned.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const locator = await page.inspector().pickLocator();
-   * console.log(locator);
-   * ```
-   *
-   */
-  pickLocator(): Promise<Locator>;
-
-  /**
-   * Starts capturing screencast frames. Frames are emitted as
-   * [inspector.on('screencastframe')](https://playwright.dev/docs/api/class-inspector#inspector-event-screencast-frame)
-   * events.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, size: ${data.length}`);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   * @param options
-   */
-  startScreencast(options?: {
-    /**
-     * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
-     * 800×800.
-     */
-    maxSize?: {
-      /**
-       * Max frame width in pixels.
-       */
-      width: number;
-
-      /**
-       * Max frame height in pixels.
-       */
-      height: number;
-    };
-  }): Promise<void>;
-
-  /**
-   * Stops the screencast started with
-   * [inspector.startScreencast([options])](https://playwright.dev/docs/api/class-inspector#inspector-start-screencast).
-   *
-   * **Usage**
-   *
-   * ```js
-   * await inspector.startScreencast();
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  stopScreencast(): Promise<void>;
-}
-
 /**
  * Keyboard provides an api for managing a virtual keyboard. The high level api is
  * [keyboard.type(text[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-type), which takes raw
@@ -21945,6 +21785,165 @@ export interface Route {
   request(): Request;
 }
 
+/**
+ * Interface for capturing screencast frames from a page.
+ */
+export interface Screencast {
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  on(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+   */
+  once(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  addListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  removeListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  off(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  prependListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Starts capturing screencast frames. Frames are emitted as
+   * [screencast.on('screencastframe')](https://playwright.dev/docs/api/class-screencast#screencast-event-screencast-frame)
+   * events.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, size: ${data.length}`);
+   * });
+   * await screencast.start({ maxSize: { width: 800, height: 600 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   * @param options
+   */
+  start(options?: {
+    /**
+     * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
+     * 800×800.
+     */
+    maxSize?: {
+      /**
+       * Max frame width in pixels.
+       */
+      width: number;
+
+      /**
+       * Max frame height in pixels.
+       */
+      height: number;
+    };
+  }): Promise<void>;
+
+  /**
+   * Stops the screencast started with
+   * [screencast.start([options])](https://playwright.dev/docs/api/class-screencast#screencast-start).
+   *
+   * **Usage**
+   *
+   * ```js
+   * await screencast.start();
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  stop(): Promise<void>;
+}
+
 /**
  * Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more
  * information.
diff --git a/packages/playwright-core/src/client/api.ts b/packages/playwright-core/src/client/api.ts
index 86b4eb2be37a0..9db785ed4f205 100644
--- a/packages/playwright-core/src/client/api.ts
+++ b/packages/playwright-core/src/client/api.ts
@@ -29,7 +29,7 @@ export { Electron, ElectronApplication } from './electron';
 export { FrameLocator, Locator } from './locator';
 export { ElementHandle } from './elementHandle';
 export { FileChooser } from './fileChooser';
-export type { Inspector } from './inspector';
+export type { Screencast } from './screencast';
 export type { Logger } from './types';
 export { TimeoutError } from './errors';
 export { Frame } from './frame';
diff --git a/packages/playwright-core/src/client/page.ts b/packages/playwright-core/src/client/page.ts
index ffc58e30b74d2..bb4a249b3b656 100644
--- a/packages/playwright-core/src/client/page.ts
+++ b/packages/playwright-core/src/client/page.ts
@@ -31,7 +31,7 @@ import { Keyboard, Mouse, Touchscreen } from './input';
 import { JSHandle, assertMaxArguments, parseResult, serializeArgument } from './jsHandle';
 import { Request, Response, Route, RouteHandler, WebSocket,  WebSocketRoute, WebSocketRouteHandler, validateHeaders } from './network';
 import { Video } from './video';
-import { Inspector } from './inspector';
+import { Screencast } from './screencast';
 import { Waiter } from './waiter';
 import { Worker } from './worker';
 import { TimeoutSettings } from './timeoutSettings';
@@ -102,7 +102,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
   readonly _bindings = new Map<string, (source: structs.BindingSource, ...args: any[]) => any>();
   readonly _timeoutSettings: TimeoutSettings;
   private _video: Video;
-  private _inspector: Inspector;
+  private _screencast: Screencast;
   readonly _opener: Page | null;
   private _closeReason: string | undefined;
   _closeWasCalled: boolean = false;
@@ -137,7 +137,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
     this._closed = initializer.isClosed;
     this._opener = Page.fromNullable(initializer.opener);
     this._video = new Video(this, this._connection, initializer.video ? Artifact.from(initializer.video) : undefined);
-    this._inspector = new Inspector(this);
+    this._screencast = new Screencast(this);
 
     this._channel.on('bindingCall', ({ binding }) => this._onBinding(BindingCall.from(binding)));
     this._channel.on('close', () => this._onClose());
@@ -287,8 +287,17 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
     return this._video;
   }
 
-  inspector(): Inspector {
-    return this._inspector;
+  screencast(): Screencast {
+    return this._screencast;
+  }
+
+  async pickLocator(): Promise<Locator> {
+    const { selector } = await this._channel.pickLocator({});
+    return this.locator(selector);
+  }
+
+  async cancelPickLocator(): Promise<void> {
+    await this._channel.cancelPickLocator({});
   }
 
   async $(selector: string, options?: { strict?: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
diff --git a/packages/playwright-core/src/client/inspector.ts b/packages/playwright-core/src/client/screencast.ts
similarity index 67%
rename from packages/playwright-core/src/client/inspector.ts
rename to packages/playwright-core/src/client/screencast.ts
index 6c42f1e3363c3..618e54e8c71cd 100644
--- a/packages/playwright-core/src/client/inspector.ts
+++ b/packages/playwright-core/src/client/screencast.ts
@@ -17,10 +17,9 @@
 import { EventEmitter } from './eventEmitter';
 
 import type * as api from '../../types/types';
-import type { Locator } from './locator';
 import type { Page } from './page';
 
-export class Inspector extends EventEmitter implements api.Inspector {
+export class Screencast extends EventEmitter implements api.Screencast {
   private readonly _page: Page;
 
   constructor(page: Page) {
@@ -29,20 +28,11 @@ export class Inspector extends EventEmitter implements api.Inspector {
     this._page._channel.on('screencastFrame', ({ data }) => this.emit('screencastframe', { data }));
   }
 
-  async pickLocator(): Promise<Locator> {
-    const { selector } = await this._page._channel.pickLocator({});
-    return this._page.locator(selector);
-  }
-
-  async cancelPickLocator(): Promise<void> {
-    await this._page._channel.cancelPickLocator({});
-  }
-
-  async startScreencast(options: { maxSize?: { width: number, height: number } } = {}): Promise<void> {
+  async start(options: { maxSize?: { width: number, height: number } } = {}): Promise<void> {
     await this._page._channel.startScreencast(options);
   }
 
-  async stopScreencast(): Promise<void> {
+  async stop(): Promise<void> {
     await this._page._channel.stopScreencast();
   }
 }
diff --git a/packages/playwright-core/src/devtools/devtoolsApp.ts b/packages/playwright-core/src/devtools/devtoolsApp.ts
index 4025f299afc02..174bddf44314e 100644
--- a/packages/playwright-core/src/devtools/devtoolsApp.ts
+++ b/packages/playwright-core/src/devtools/devtoolsApp.ts
@@ -48,11 +48,11 @@ function readBody(request: http.IncomingMessage): Promise<any> {
   });
 }
 
-async function parseRequest(request: http.IncomingMessage): Promise<{ sessionGuid: string }> {
+async function parseRequest(request: http.IncomingMessage): Promise<{ guid: string }> {
   const body = await readBody(request);
-  if (!body.sessionGuid)
+  if (!body.guid)
     throw new Error('Dashboard app is too old, please close it and open again');
-  return { sessionGuid: body.sessionGuid };
+  return { guid: body.guid };
 }
 
 function sendJSON(response: http.ServerResponse, data: any, statusCode = 200) {
@@ -62,17 +62,17 @@ function sendJSON(response: http.ServerResponse, data: any, statusCode = 200) {
 }
 
 async function loadBrowserDescriptorSessions(wsPath: string): Promise<SessionStatus[]> {
-  const servers = await serverRegistry.list();
+  const entriesByWorkspace = await serverRegistry.list();
   const sessions: SessionStatus[] = [];
-  for (const [, browsers] of servers) {
-    for (const browser of browsers) {
+  for (const [, entries] of entriesByWorkspace) {
+    for (const entry of entries) {
       let wsUrl: string | undefined;
-      if (browser.canConnect) {
+      if (entry.canConnect) {
         const url = new URL(wsPath, 'http://localhost');
-        url.searchParams.set('sessionGuid', browser.guid);
+        url.searchParams.set('guid', entry.browser.guid);
         wsUrl = url.pathname + url.search;
       }
-      sessions.push({ browserDescriptor: browser, wsUrl });
+      sessions.push({ ...entry, wsUrl });
     }
   }
   return sessions;
@@ -91,10 +91,10 @@ async function handleApiRequest(httpServer: HttpServer, request: http.IncomingMe
   }
 
   if (apiPath === '/api/sessions/close' && request.method === 'POST') {
-    const { sessionGuid } = await parseRequest(request);
+    const { guid } = await parseRequest(request);
     let browser: api.Browser;
     try {
-      const browserDescriptor = serverRegistry.readDescriptor(sessionGuid);
+      const browserDescriptor = serverRegistry.readDescriptor(guid);
       browser = await connectToBrowserAcrossVersions(browserDescriptor);
     } catch (e) {
       sendJSON(response, { error: 'Failed to connect to browser socket: ' + e.message }, 500);
@@ -112,9 +112,9 @@ async function handleApiRequest(httpServer: HttpServer, request: http.IncomingMe
   }
 
   if (apiPath === '/api/sessions/delete-data' && request.method === 'POST') {
-    const { sessionGuid } = await parseRequest(request);
+    const { guid } = await parseRequest(request);
     try {
-      await serverRegistry.deleteUserData(sessionGuid);
+      await serverRegistry.deleteUserData(guid);
     } catch (e) {
       sendJSON(response, { error: 'Failed to delete session data: ' + e.message }, 500);
       return;
@@ -141,16 +141,16 @@ async function openDevToolsApp(): Promise<api.Page> {
   });
 
   httpServer.createWebSocket(url => {
-    const sessionGuid = url.searchParams.get('sessionGuid');
-    if (!sessionGuid)
+    const guid = url.searchParams.get('guid');
+    if (!guid)
       throw new Error('Unsupported WebSocket URL: ' + url.toString());
-    const browserDescriptor = serverRegistry.readDescriptor(sessionGuid);
+    const browserDescriptor = serverRegistry.readDescriptor(guid);
 
     const cdpPageId = url.searchParams.get('cdpPageId');
     if (cdpPageId) {
-      const connection = browserGuidToDevToolsConnection.get(sessionGuid);
+      const connection = browserGuidToDevToolsConnection.get(guid);
       if (!connection)
-        throw new Error('CDP connection not found for session: ' + sessionGuid);
+        throw new Error('CDP connection not found for session: ' + guid);
       const page = connection.pageForId(cdpPageId);
       if (!page)
         throw new Error('Page not found for page ID: ' + cdpPageId);
@@ -159,9 +159,9 @@ async function openDevToolsApp(): Promise<api.Page> {
 
     const cdpUrl = new URL(httpServer.urlPrefix('human-readable'));
     cdpUrl.pathname = httpServer.wsGuid()!;
-    cdpUrl.searchParams.set('sessionGuid', sessionGuid);
-    const connection = new DevToolsConnection(browserDescriptor, cdpUrl, () => browserGuidToDevToolsConnection.delete(sessionGuid));
-    browserGuidToDevToolsConnection.set(sessionGuid, connection);
+    cdpUrl.searchParams.set('guid', guid);
+    const connection = new DevToolsConnection(browserDescriptor, cdpUrl, () => browserGuidToDevToolsConnection.delete(guid));
+    browserGuidToDevToolsConnection.set(guid, connection);
     return connection;
   });
 
diff --git a/packages/playwright-core/src/devtools/devtoolsController.ts b/packages/playwright-core/src/devtools/devtoolsController.ts
index a1c5a45dc94d7..31bbdfcb76bfe 100644
--- a/packages/playwright-core/src/devtools/devtoolsController.ts
+++ b/packages/playwright-core/src/devtools/devtoolsController.ts
@@ -101,6 +101,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
     this._contextListeners.forEach(d => d.dispose());
     this._contextListeners = [];
     this._onclose();
+    this._browser?.close().catch(() => {});
   }
 
   async dispatch(method: string, params: any): Promise<any> {
@@ -177,7 +178,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
     if (this.selectedPage) {
       this._pageListeners.forEach(d => d.dispose());
       this._pageListeners = [];
-      await this.selectedPage.inspector().stopScreencast();
+      await this.selectedPage.screencast().stop();
     }
 
     this.selectedPage = page;
@@ -197,11 +198,11 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
           if (frame === page.mainFrame())
             this._sendTabList();
         }),
-        eventsHelper.addEventListener(page.inspector(), 'screencastframe', ({ data }) => this._writeFrame(data, page.viewportSize()?.width ?? 0, page.viewportSize()?.height ?? 0))
+        eventsHelper.addEventListener(page.screencast(), 'screencastframe', ({ data }) => this._writeFrame(data, page.viewportSize()?.width ?? 0, page.viewportSize()?.height ?? 0))
     );
 
     const maxSize = { width: 1280, height: 800 };
-    await page.inspector().startScreencast({ maxSize });
+    await page.screencast().start({ maxSize });
   }
 
   private _deselectPage() {
@@ -209,7 +210,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
       return;
     this._pageListeners.forEach(d => d.dispose());
     this._pageListeners = [];
-    this.selectedPage.inspector().stopScreencast().catch(() => {});
+    this.selectedPage.screencast().stop().catch(() => {});
     this.selectedPage = null;
     this._lastFrameData = null;
     this._lastViewportSize = null;
@@ -218,12 +219,12 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
   async pickLocator() {
     if (!this.selectedPage)
       return;
-    const locator = await this.selectedPage.inspector().pickLocator();
+    const locator = await this.selectedPage.pickLocator();
     this._emit('elementPicked', { selector: locator.toString() });
   }
 
   async cancelPickLocator() {
-    await this.selectedPage?.inspector().cancelPickLocator();
+    await this.selectedPage?.cancelPickLocator();
   }
 
   private _sendCachedState() {
@@ -259,7 +260,7 @@ export class DevToolsConnection implements Transport, DevToolsChannel {
   }
 
   private async _devtoolsUrl(page: api.Page) {
-    const cdpPort = this._browserDescriptor.browser.launchOptions.cdpPort;
+    const cdpPort = (this._browserDescriptor.browser.launchOptions as any).cdpPort;
     if (cdpPort)
       return new URL(`http://localhost:${cdpPort}/devtools/`);
 
diff --git a/packages/playwright-core/src/mcp/config.d.ts b/packages/playwright-core/src/mcp/config.d.ts
index 35c5ca61fb225..99ad58fbf9523 100644
--- a/packages/playwright-core/src/mcp/config.d.ts
+++ b/packages/playwright-core/src/mcp/config.d.ts
@@ -137,11 +137,6 @@ export type Config = {
    */
   saveSession?: boolean;
 
-  /**
-   * Reuse the same browser context between all connected HTTP clients.
-   */
-  sharedBrowserContext?: boolean;
-
   /**
    * Secrets are used to prevent LLM from getting sensitive data while
    * automating scenarios such as authentication.
diff --git a/packages/playwright-core/src/mcp/config.ts b/packages/playwright-core/src/mcp/config.ts
index 577da213a873e..1088e834a6c14 100644
--- a/packages/playwright-core/src/mcp/config.ts
+++ b/packages/playwright-core/src/mcp/config.ts
@@ -64,7 +64,6 @@ export type CLIOptions = {
   proxyServer?: string;
   saveSession?: boolean;
   secrets?: Record<string, string>;
-  sharedBrowserContext?: boolean;
   snapshotMode?: 'incremental' | 'full' | 'none';
   storageState?: string;
   testIdAttribute?: string;
@@ -253,7 +252,6 @@ export function configFromCLIOptions(cliOptions: CLIOptions): Config & { configF
     codegen: cliOptions.codegen,
     saveSession: cliOptions.saveSession,
     secrets: cliOptions.secrets,
-    sharedBrowserContext: cliOptions.sharedBrowserContext,
     snapshot: cliOptions.snapshotMode ? { mode: cliOptions.snapshotMode } : undefined,
     outputMode: cliOptions.outputMode,
     outputDir: cliOptions.outputDir,
diff --git a/packages/playwright-core/src/mcp/configIni.ts b/packages/playwright-core/src/mcp/configIni.ts
index 966e4ab617c9b..29c4c743e7955 100644
--- a/packages/playwright-core/src/mcp/configIni.ts
+++ b/packages/playwright-core/src/mcp/configIni.ts
@@ -160,7 +160,6 @@ const longhandTypes: Record<string, LonghandType> = {
   'saveSession': 'boolean',
   'saveTrace': 'boolean',
   'saveVideo': 'size',
-  'sharedBrowserContext': 'boolean',
   'outputDir': 'string',
   'outputMode': 'string',
   'imageResponses': 'string',
diff --git a/packages/playwright-core/src/mcp/program.ts b/packages/playwright-core/src/mcp/program.ts
index c60b789c088c5..f82bf80b47755 100644
--- a/packages/playwright-core/src/mcp/program.ts
+++ b/packages/playwright-core/src/mcp/program.ts
@@ -26,6 +26,7 @@ import { testDebug } from './log';
 
 import type { Command } from '../utilsBundle';
 import type { ClientInfo } from './sdk/server';
+import type * as playwright from '../..';
 
 export function decorateMCPCommand(command: Command, version: string) {
   command
@@ -62,7 +63,6 @@ export function decorateMCPCommand(command: Command, version: string) {
       .option('--sandbox', 'enable the sandbox for all process types that are normally not sandboxed.')
       .option('--save-session', 'Whether to save the Playwright MCP session into the output directory.')
       .option('--secrets <path>', 'path to a file containing secrets in the dotenv format', dotenvFileLoader)
-      .option('--shared-browser-context', 'reuse the same browser context between all connected HTTP clients.')
       .option('--snapshot-mode <mode>', 'when taking snapshots for responses, specifies the mode to use. Can be "incremental", "full", or "none". Default is incremental.')
       .option('--storage-state <path>', 'path to the storage state file for isolated sessions.')
       .option('--test-id-attribute <attribute>', 'specify the attribute to use for test ids, defaults to "data-testid"')
@@ -107,14 +107,18 @@ export function decorateMCPCommand(command: Command, version: string) {
           return;
         }
 
-        const sharedBrowser = config.sharedBrowserContext ? await createBrowser(config, { cwd: process.cwd() }) : undefined;
+        const useSharedBrowser = !!config.browser.userDataDir;
+        let sharedBrowser: playwright.Browser | undefined;
         let clientCount = 0;
+
         const factory: mcpServer.ServerBackendFactory = {
           name: 'Playwright',
           nameInConfig: 'playwright',
           version,
           toolSchemas: tools.map(tool => tool.schema),
           create: async (clientInfo: ClientInfo) => {
+            if (useSharedBrowser && clientCount === 0)
+              sharedBrowser = await createBrowser(config, clientInfo);
             clientCount++;
             const browser = sharedBrowser || await createBrowser(config, clientInfo);
             const browserContext = config.browser.isolated ? await browser.newContext(config.browser.contextOptions) : browser.contexts()[0];
@@ -126,6 +130,7 @@ export function decorateMCPCommand(command: Command, version: string) {
               return;
 
             testDebug('close browser');
+            sharedBrowser = undefined;
             const browserContext = (backend as BrowserServerBackend).browserContext;
             await browserContext.close().catch(() => { });
             await browserContext.browser()!.close().catch(() => { });
diff --git a/packages/playwright-core/src/server/browser.ts b/packages/playwright-core/src/server/browser.ts
index a3247248246b6..c065e68f4dc12 100644
--- a/packages/playwright-core/src/server/browser.ts
+++ b/packages/playwright-core/src/server/browser.ts
@@ -26,7 +26,7 @@ import { Page } from './page';
 import { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
 import { PlaywrightPipeServer } from '../remote/playwrightPipeServer';
 import { PlaywrightWebSocketServer } from '../remote/playwrightWebSocketServer';
-import { serverRegistry } from '../serverRegistry';
+import { BrowserInfo, serverRegistry } from '../serverRegistry';
 
 import type * as types from './types';
 import type { ProxySettings } from './types';
@@ -35,6 +35,7 @@ import type * as channels from '@protocol/channels';
 import type { ChildProcess } from 'child_process';
 import type { Language } from '../utils';
 import type { Progress } from './progress';
+import type * as playwright from '../..';
 
 export interface BrowserProcess {
   onclose?: ((exitCode: number | null, signal: string | null) => void);
@@ -213,7 +214,6 @@ export class BrowserServer {
   private _wsServer?: PlaywrightWebSocketServer;
   private _pipeSocketPath?: string;
   private _isStarted = false;
-  private _sessionGuid?: string;
 
   constructor(browser: Browser) {
     this._browser = browser;
@@ -236,7 +236,13 @@ export class BrowserServer {
       result.wsEndpoint = await this._wsServer.listen(0, 'localhost', path);
     }
 
-    this._sessionGuid = await serverRegistry.create(this._browser, {
+    const browserInfo: BrowserInfo = {
+      guid: this._browser.guid,
+      browserName: this._browser.options.browserType,
+      launchOptions: asClientLaunchOptions(this._browser.options.originalLaunchOptions),
+      userDataDir: this._browser.options.userDataDir,
+    };
+    await serverRegistry.create(browserInfo, {
       title,
       wsEndpoint: result.wsEndpoint,
       pipeName: result.pipeName,
@@ -246,9 +252,8 @@ export class BrowserServer {
   }
 
   async stop() {
-    if (this._sessionGuid)
-      await serverRegistry.delete(this._browser, this._sessionGuid);
-    this._sessionGuid = undefined;
+    if (!this._browser.options.userDataDir)
+      await serverRegistry.delete(this._browser.guid);
     if (this._pipeSocketPath && process.platform !== 'win32')
       await fs.promises.unlink(this._pipeSocketPath).catch(() => {});
     await this._pipeServer?.close();
@@ -267,3 +272,10 @@ export class BrowserServer {
     return path.join(socketsDir, socketName);
   }
 }
+
+function asClientLaunchOptions(serverOptions: types.LaunchOptions): playwright.LaunchOptions {
+  return {
+    ...serverOptions,
+    env: serverOptions.env ? Object.fromEntries(serverOptions.env.map(({ name, value }) => [name, value])) : undefined,
+  };
+}
diff --git a/packages/playwright-core/src/server/chromium/crServiceWorker.ts b/packages/playwright-core/src/server/chromium/crServiceWorker.ts
index 31d0ded84e466..b49bf0748c910 100644
--- a/packages/playwright-core/src/server/chromium/crServiceWorker.ts
+++ b/packages/playwright-core/src/server/chromium/crServiceWorker.ts
@@ -23,6 +23,7 @@ import { toConsoleMessageLocation } from './crProtocolHelper';
 
 import type { CRBrowserContext } from './crBrowser';
 import type { CRSession } from './crConnection';
+import type { Protocol } from './protocol';
 
 export class CRServiceWorker extends Worker {
   readonly browserContext: CRBrowserContext;
@@ -35,13 +36,17 @@ export class CRServiceWorker extends Worker {
     this.browserContext = browserContext;
     if (!process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK)
       this._networkManager = new CRNetworkManager(null, this);
-    session.once('Runtime.executionContextCreated', event => {
+
+    session.on('Inspector.targetCrashed', () => this._prepareContextForRestart());
+
+    session.on('Runtime.executionContextCreated', (event: Protocol.Runtime.executionContextCreatedPayload) => {
       this.createExecutionContext(new CRExecutionContext(session, event.context));
+      if (this.browserContext._browser.majorVersion() < 143)
+        this.workerScriptLoaded();
     });
+
     if (this.browserContext._browser.majorVersion() >= 143)
       session.on('Inspector.workerScriptLoaded', () => this.workerScriptLoaded());
-    else
-      this.workerScriptLoaded();
 
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
       this.updateRequestInterception();
@@ -59,8 +64,8 @@ export class CRServiceWorker extends Worker {
       this.browserContext.emit(BrowserContext.Events.Console, message);
     });
 
-    session.send('Runtime.enable', {}).catch(e => { });
-    session.send('Runtime.runIfWaitingForDebugger').catch(e => { });
+    session.send('Runtime.enable', {}).catch(e => {});
+    session.send('Runtime.runIfWaitingForDebugger').catch(e => {});
     session.on('Inspector.targetReloadedAfterCrash', () => {
       // Resume service worker after restart.
       session._sendMayFail('Runtime.runIfWaitingForDebugger', {});
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 95cd244ebb996..8b3de659e5c8c 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -915,6 +915,16 @@ export class Worker extends SdkObject<WorkerEventMap> {
       this._executionContextPromise.resolve(this.existingExecutionContext);
   }
 
+  protected _prepareContextForRestart() {
+    if (this.existingExecutionContext)
+      this.existingExecutionContext.contextDestroyed('Service worker restarted');
+    this.existingExecutionContext = null;
+    // Reset so createExecutionContext() waits for workerScriptLoaded() before resolving —
+    // mirroring initial startup and ensuring the script has run before evaluations proceed.
+    this._workerScriptLoaded = false;
+    this._executionContextPromise = new ManualPromise<js.ExecutionContext>();
+  }
+
   didClose() {
     if (this.existingExecutionContext)
       this.existingExecutionContext.contextDestroyed('Worker was closed');
diff --git a/packages/playwright-core/src/serverRegistry.ts b/packages/playwright-core/src/serverRegistry.ts
index e9d28433e6474..4aa14109697b4 100644
--- a/packages/playwright-core/src/serverRegistry.ts
+++ b/packages/playwright-core/src/serverRegistry.ts
@@ -18,30 +18,30 @@ import fs from 'fs';
 import net from 'net';
 import path from 'path';
 import os from 'os';
-import crypto from 'crypto';
 
-import type { Browser } from './server/browser';
-import type { LaunchOptions } from './server/types';
-import type { BrowserName } from './server/registry/index';
+// Only client depenencies with backward compatibility guarantees should be imported here.
+import type { LaunchOptions } from '../types/types';
 
 const packageVersion = require('../package.json').version;
 
 export type BrowserInfo = {
+  guid: string;
+  browserName: 'chromium' | 'firefox' | 'webkit';
+  userDataDir?: string;
+  launchOptions: LaunchOptions;
+};
+
+export type EndpointInfo = {
   title: string;
   wsEndpoint?: string;
   pipeName?: string;
   workspaceDir?: string;
 };
 
-export type BrowserDescriptor = BrowserInfo & {
-  guid: string;
+export type BrowserDescriptor = EndpointInfo & {
   playwrightVersion: string;
   playwrightLib: string;
-  browser: {
-    browserName: BrowserName;
-    launchOptions: LaunchOptions;
-    userDataDir?: string;
-  };
+  browser: BrowserInfo;
 };
 
 export type BrowserStatus = BrowserDescriptor & { canConnect: boolean };
@@ -85,37 +85,28 @@ class ServerRegistry {
     return resolvedResult;
   }
 
-  async create(browser: Browser, info: BrowserInfo): Promise<string> {
-    const guid = createGuid();
-    const file = path.join(this._browsersDir(), guid);
+  async create(browser: BrowserInfo, endpoint: EndpointInfo) {
+    const file = path.join(this._browsersDir(), browser.guid);
     await fs.promises.mkdir(this._browsersDir(), { recursive: true });
     const descriptor: BrowserDescriptor = {
-      guid,
       playwrightVersion: packageVersion,
       playwrightLib: require.resolve('..'),
-      title: info.title,
-      browser: {
-        browserName: browser.options.browserType,
-        launchOptions: browser.options.originalLaunchOptions,
-        userDataDir: browser.options.userDataDir,
-      },
-      wsEndpoint: info.wsEndpoint,
-      pipeName: info.pipeName,
-      workspaceDir: info.workspaceDir,
+      title: endpoint.title,
+      browser,
+      wsEndpoint: endpoint.wsEndpoint,
+      pipeName: endpoint.pipeName,
+      workspaceDir: endpoint.workspaceDir,
     };
     await fs.promises.writeFile(file, JSON.stringify(descriptor), 'utf-8');
-    return guid;
   }
 
-  async delete(browser: Browser, sessionGuid: string): Promise<void> {
-    if (browser.options.userDataDir)
-      return;
-    const file = path.join(this._browsersDir(), sessionGuid);
+  async delete(guid: string): Promise<void> {
+    const file = path.join(this._browsersDir(), guid);
     await fs.promises.unlink(file).catch(() => {});
   }
 
-  async deleteUserData(sessionGuid: string): Promise<void> {
-    const filePath = path.join(this._browsersDir(), sessionGuid);
+  async deleteUserData(guid: string): Promise<void> {
+    const filePath = path.join(this._browsersDir(), guid);
     const content = await fs.promises.readFile(filePath, 'utf-8');
     const descriptor: BrowserDescriptor = JSON.parse(content);
     if (descriptor.browser.userDataDir)
@@ -123,8 +114,8 @@ class ServerRegistry {
     await fs.promises.unlink(filePath);
   }
 
-  readDescriptor(sessionGuid: string): BrowserDescriptor {
-    const filePath = path.join(this._browsersDir(), sessionGuid);
+  readDescriptor(guid: string): BrowserDescriptor {
+    const filePath = path.join(this._browsersDir(), guid);
     const content = fs.readFileSync(filePath, 'utf-8');
     const descriptor: BrowserDescriptor = JSON.parse(content);
     return descriptor;
@@ -146,10 +137,6 @@ class ServerRegistry {
   }
 }
 
-function createGuid(): string {
-  return crypto.randomBytes(16).toString('hex');
-}
-
 async function canConnect(descriptor: BrowserDescriptor): Promise<boolean> {
   if (descriptor.pipeName) {
     return await new Promise(resolve => {
diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.ts
index c7b0375a83056..94a3e2df326ff 100644
--- a/packages/playwright-core/types/types.d.ts
+++ b/packages/playwright-core/types/types.d.ts
@@ -2187,6 +2187,12 @@ export interface Page {
    */
   bringToFront(): Promise<void>;
 
+  /**
+   * Cancels an ongoing [page.pickLocator()](https://playwright.dev/docs/api/class-page#page-pick-locator) call by
+   * deactivating pick locator mode. If no pick locator mode is active, this method is a no-op.
+   */
+  cancelPickLocator(): Promise<void>;
+
   /**
    * **NOTE** Use locator-based [locator.check([options])](https://playwright.dev/docs/api/class-locator#locator-check) instead.
    * Read more about [locators](https://playwright.dev/docs/locators).
@@ -3502,24 +3508,6 @@ export interface Page {
     timeout?: number;
   }): Promise<string>;
 
-  /**
-   * Returns the [Inspector](https://playwright.dev/docs/api/class-inspector) object associated with this page.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastFrame', data => {
-   *   console.log('received frame, jpeg size:', data.length);
-   * });
-   * await inspector.startScreencast();
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  inspector(): Inspector;
-
   /**
    * **NOTE** Use locator-based [locator.isChecked([options])](https://playwright.dev/docs/api/class-locator#locator-is-checked)
    * instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -3922,6 +3910,21 @@ export interface Page {
     width?: string|number;
   }): Promise<Buffer>;
 
+  /**
+   * Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+   * Once the user clicks an element, the mode is deactivated and the
+   * [Locator](https://playwright.dev/docs/api/class-locator) for the picked element is returned.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const locator = await page.pickLocator();
+   * console.log(locator);
+   * ```
+   *
+   */
+  pickLocator(): Promise<Locator>;
+
   /**
    * **NOTE** Use locator-based [locator.press(key[, options])](https://playwright.dev/docs/api/class-locator#locator-press)
    * instead. Read more about [locators](https://playwright.dev/docs/locators).
@@ -4225,6 +4228,24 @@ export interface Page {
    */
   routeWebSocket(url: string|RegExp|URLPattern|((url: URL) => boolean), handler: ((websocketroute: WebSocketRoute) => Promise<any>|any)): Promise<void>;
 
+  /**
+   * Returns the [Screencast](https://playwright.dev/docs/api/class-screencast) object associated with this page.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastFrame', data => {
+   *   console.log('received frame, jpeg size:', data.length);
+   * });
+   * await screencast.start();
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  screencast(): Screencast;
+
   /**
    * Returns the buffer with the captured screenshot.
    * @param options
@@ -20580,187 +20601,6 @@ export interface FrameLocator {
   owner(): Locator;
 }
 
-/**
- * Interface to the Playwright inspector.
- */
-export interface Inspector {
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  on(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
-   */
-  once(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  addListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Removes an event listener added by `on` or `addListener`.
-   */
-  removeListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Removes an event listener added by `on` or `addListener`.
-   */
-  off(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Emitted for each captured JPEG screencast frame while the screencast is running.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
-   *   require('fs').writeFileSync('frame.jpg', data);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 1200, height: 800 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  prependListener(event: 'screencastframe', listener: (data: {
-    /**
-     * JPEG-encoded frame data.
-     */
-    data: Buffer;
-  }) => any): this;
-
-  /**
-   * Cancels an ongoing
-   * [inspector.pickLocator()](https://playwright.dev/docs/api/class-inspector#inspector-pick-locator) call by
-   * deactivating pick locator mode. If no pick locator mode is active, this method is a no-op.
-   */
-  cancelPickLocator(): Promise<void>;
-
-  /**
-   * Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
-   * Once the user clicks an element, the mode is deactivated and the
-   * [Locator](https://playwright.dev/docs/api/class-locator) for the picked element is returned.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const locator = await page.inspector().pickLocator();
-   * console.log(locator);
-   * ```
-   *
-   */
-  pickLocator(): Promise<Locator>;
-
-  /**
-   * Starts capturing screencast frames. Frames are emitted as
-   * [inspector.on('screencastframe')](https://playwright.dev/docs/api/class-inspector#inspector-event-screencast-frame)
-   * events.
-   *
-   * **Usage**
-   *
-   * ```js
-   * const inspector = page.inspector();
-   * inspector.on('screencastframe', ({ data, width, height }) => {
-   *   console.log(`frame ${width}x${height}, size: ${data.length}`);
-   * });
-   * await inspector.startScreencast({ maxSize: { width: 800, height: 600 } });
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   * @param options
-   */
-  startScreencast(options?: {
-    /**
-     * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
-     * 800×800.
-     */
-    maxSize?: {
-      /**
-       * Max frame width in pixels.
-       */
-      width: number;
-
-      /**
-       * Max frame height in pixels.
-       */
-      height: number;
-    };
-  }): Promise<void>;
-
-  /**
-   * Stops the screencast started with
-   * [inspector.startScreencast([options])](https://playwright.dev/docs/api/class-inspector#inspector-start-screencast).
-   *
-   * **Usage**
-   *
-   * ```js
-   * await inspector.startScreencast();
-   * // ... perform actions ...
-   * await inspector.stopScreencast();
-   * ```
-   *
-   */
-  stopScreencast(): Promise<void>;
-}
-
 /**
  * Keyboard provides an api for managing a virtual keyboard. The high level api is
  * [keyboard.type(text[, options])](https://playwright.dev/docs/api/class-keyboard#keyboard-type), which takes raw
@@ -21945,6 +21785,165 @@ export interface Route {
   request(): Request;
 }
 
+/**
+ * Interface for capturing screencast frames from a page.
+ */
+export interface Screencast {
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  on(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+   */
+  once(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  addListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  removeListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  off(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Emitted for each captured JPEG screencast frame while the screencast is running.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, jpeg size: ${data.length}`);
+   *   require('fs').writeFileSync('frame.jpg', data);
+   * });
+   * await screencast.start({ maxSize: { width: 1200, height: 800 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  prependListener(event: 'screencastframe', listener: (data: {
+    /**
+     * JPEG-encoded frame data.
+     */
+    data: Buffer;
+  }) => any): this;
+
+  /**
+   * Starts capturing screencast frames. Frames are emitted as
+   * [screencast.on('screencastframe')](https://playwright.dev/docs/api/class-screencast#screencast-event-screencast-frame)
+   * events.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const screencast = page.screencast();
+   * screencast.on('screencastframe', ({ data, width, height }) => {
+   *   console.log(`frame ${width}x${height}, size: ${data.length}`);
+   * });
+   * await screencast.start({ maxSize: { width: 800, height: 600 } });
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   * @param options
+   */
+  start(options?: {
+    /**
+     * Maximum screencast frame dimensions. The output frame may be smaller to preserve the page aspect ratio. Defaults to
+     * 800×800.
+     */
+    maxSize?: {
+      /**
+       * Max frame width in pixels.
+       */
+      width: number;
+
+      /**
+       * Max frame height in pixels.
+       */
+      height: number;
+    };
+  }): Promise<void>;
+
+  /**
+   * Stops the screencast started with
+   * [screencast.start([options])](https://playwright.dev/docs/api/class-screencast#screencast-start).
+   *
+   * **Usage**
+   *
+   * ```js
+   * await screencast.start();
+   * // ... perform actions ...
+   * await screencast.stop();
+   * ```
+   *
+   */
+  stop(): Promise<void>;
+}
+
 /**
  * Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/docs/extensibility) for more
  * information.
diff --git a/tests/assets/extension-mv3-sw-lifecycle/background.js b/tests/assets/extension-mv3-sw-lifecycle/background.js
new file mode 100644
index 0000000000000..4914caadec484
--- /dev/null
+++ b/tests/assets/extension-mv3-sw-lifecycle/background.js
@@ -0,0 +1,2 @@
+// Each time the service worker starts (or restarts), this runs fresh.
+globalThis.startTime = Date.now();
diff --git a/tests/assets/extension-mv3-sw-lifecycle/manifest.json b/tests/assets/extension-mv3-sw-lifecycle/manifest.json
new file mode 100644
index 0000000000000..ad6a4ed645dd9
--- /dev/null
+++ b/tests/assets/extension-mv3-sw-lifecycle/manifest.json
@@ -0,0 +1,8 @@
+{
+  "name": "SW Lifecycle Test Extension",
+  "version": "0.1",
+  "background": {
+    "service_worker": "background.js"
+  },
+  "manifest_version": 3
+}
diff --git a/tests/library/chromium/extensions.spec.ts b/tests/library/chromium/extensions.spec.ts
index e7d48030df66d..f1015763ed4df 100644
--- a/tests/library/chromium/extensions.spec.ts
+++ b/tests/library/chromium/extensions.spec.ts
@@ -42,6 +42,50 @@ it.skip(({ isHeadlessShell }) => isHeadlessShell, 'Headless Shell has no support
 it.describe('MV3', () => {
   it.skip(({ channel }) => channel?.startsWith('chrome'), '--load-extension is not supported in Chrome anymore. https://groups.google.com/a/chromium.org/g/chromium-extensions/c/1-g8EFx2BBY/m/S0ET5wPjCAAJ');
 
+  it('should support service worker stop and restart lifecycle', {
+    annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/39475' }
+  }, async ({ launchPersistentContext, asset }) => {
+    const extensionPath = asset('extension-mv3-sw-lifecycle');
+    const context = await launchPersistentContext(extensionPath);
+
+    const serviceWorkers = context.serviceWorkers();
+    const sw1 = serviceWorkers.length ? serviceWorkers[0] : await context.waitForEvent('serviceworker');
+    const startTime1 = await sw1.evaluate(() => (globalThis as any).startTime);
+
+    // stopWorker keeps the same CDP target alive, matching Chrome's natural idle suspension behavior.
+    const page = await context.newPage();
+    const cdp = await context.newCDPSession(page);
+
+    let versionId: string | undefined;
+    let scopeURL: string | undefined;
+    let runningStatus: string | undefined;
+    cdp.on('ServiceWorker.workerVersionUpdated', ({ versions }: any) => {
+      const v = versions[0];
+      if (!v)
+        return;
+      versionId = v.versionId;
+      runningStatus = v.runningStatus;
+    });
+    cdp.on('ServiceWorker.workerRegistrationUpdated', ({ registrations }: any) => {
+      if (registrations.length)
+        scopeURL = registrations[0].scopeURL;
+    });
+    await cdp.send('ServiceWorker.enable');
+    await expect.poll(() => versionId && scopeURL, { timeout: 5000 }).toBeTruthy();
+
+    await cdp.send('ServiceWorker.stopWorker', { versionId });
+    // Wait for full stop before triggering restart.
+    await expect.poll(() => runningStatus, { timeout: 5000 }).toBe('stopped');
+    await cdp.send('ServiceWorker.startWorker', { scopeURL });
+    await expect.poll(() => runningStatus, { timeout: 5000 }).toBe('running');
+
+    const startTime2 = await sw1.evaluate(() => (globalThis as any).startTime);
+    expect(startTime2).toBeGreaterThan(startTime1);
+    expect(context.serviceWorkers()).toStrictEqual([sw1]); // same object, no new event
+
+    await context.close();
+  });
+
   it('should give access to the service worker', async ({ launchPersistentContext, asset }) => {
     const extensionPath = asset('extension-mv3-simple');
     const context = await launchPersistentContext(extensionPath);
diff --git a/tests/library/inspector/recorder-api.spec.ts b/tests/library/inspector/recorder-api.spec.ts
index c0874ff83884f..75fd778003d96 100644
--- a/tests/library/inspector/recorder-api.spec.ts
+++ b/tests/library/inspector/recorder-api.spec.ts
@@ -152,11 +152,11 @@ test('should disable recorder', async ({ context }) => {
   expect(log.action('click')).toHaveLength(2);
 });
 
-test('inspector.pickLocator should return locator for picked element', async ({ page }) => {
+test('page.pickLocator should return locator for picked element', async ({ page }) => {
   await page.setContent(`<button>Submit</button>`);
 
   const scriptReady = page.waitForEvent('console', msg => msg.text() === 'Recorder script ready for test');
-  const pickPromise = page.inspector().pickLocator();
+  const pickPromise = page.pickLocator();
   await scriptReady;
 
   const box = await page.getByRole('button', { name: 'Submit' }).boundingBox();
@@ -166,15 +166,15 @@ test('inspector.pickLocator should return locator for picked element', async ({
   await expect(locator).toHaveText('Submit');
 });
 
-test('inspector.cancelPickLocator should cancel ongoing pickLocator', async ({ page }) => {
+test('page.cancelPickLocator should cancel ongoing pickLocator', async ({ page }) => {
   await page.setContent(`<button>Submit</button>`);
 
   const scriptReady = page.waitForEvent('console', msg => msg.text() === 'Recorder script ready for test');
-  const pickPromise = page.inspector().pickLocator();
+  const pickPromise = page.pickLocator();
   await scriptReady;
 
   await Promise.all([
-    page.inspector().cancelPickLocator(),
+    page.cancelPickLocator(),
     expect(pickPromise).rejects.toThrow('Locator picking was cancelled'),
   ]);
 });
diff --git a/tests/library/screencast.spec.ts b/tests/library/screencast.spec.ts
new file mode 100644
index 0000000000000..f17bac14639f8
--- /dev/null
+++ b/tests/library/screencast.spec.ts
@@ -0,0 +1,125 @@
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect, browserTest as test } from '../config/browserTest';
+import { rafraf } from '../config/utils';
+
+test.skip(({ mode }) => mode !== 'default', 'screencast is not available in remote mode');
+
+test('screencast.start emits screencastframe events', async ({ browser, server, trace }) => {
+  test.skip(trace === 'on', 'trace=on has different screencast image configuration');
+  const context = await browser.newContext({ viewport: { width: 1000, height: 400 } });
+  const page = await context.newPage();
+
+  const frames: { data: Buffer }[] = [];
+  page.screencast().on('screencastframe', frame => frames.push(frame));
+
+  const maxSize = { width: 500, height: 400 };
+  await page.screencast().start({ maxSize });
+  await page.goto(server.EMPTY_PAGE);
+  await page.evaluate(() => document.body.style.backgroundColor = 'red');
+  await rafraf(page, 100);
+  await page.screencast().stop();
+
+  expect(frames.length).toBeGreaterThan(0);
+  for (const frame of frames) {
+    // Each frame must be a valid JPEG (starts with FF D8)
+    expect(frame.data[0]).toBe(0xff);
+    expect(frame.data[1]).toBe(0xd8);
+    const { width, height } = jpegDimensions(frame.data);
+    // Frame should be scaled down to fit the maximum size.
+    expect(width).toBe(500);
+    expect(height).toBe(200);
+  }
+
+  await context.close();
+});
+
+test('start throws if already running', async ({ browser, trace }) => {
+  test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+  const size = { width: 500, height: 400 };
+  const context = await browser.newContext({ viewport: size });
+  const page = await context.newPage();
+
+  await page.screencast().start({ maxSize: size });
+  await expect(page.screencast().start({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running');
+
+  await page.screencast().stop();
+  await context.close();
+});
+
+test('start allows restart with different options after stop', async ({ browser, trace }) => {
+  test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+  const context = await browser.newContext({ viewport: { width: 500, height: 400 } });
+  const page = await context.newPage();
+
+  await page.screencast().start({ maxSize: { width: 500, height: 400 } });
+  await page.screencast().stop();
+  // Different options should succeed once the previous screencast is stopped.
+  await page.screencast().start({ maxSize: { width: 320, height: 240 } });
+  await page.screencast().stop();
+  await context.close();
+});
+
+test('start throws when video recording is running with different params', async ({ browser, trace }) => {
+  test.skip(trace === 'on', 'trace=on enables screencast with different options');
+
+  const videoSize = { width: 500, height: 400 };
+  const context = await browser.newContext({ viewport: videoSize });
+  const page = await context.newPage();
+
+  await page.video().start({ size: videoSize });
+  await expect(page.screencast().start({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running with different options');
+
+  await page.video().stop();
+  await context.close();
+});
+
+test('video.start does not emit screencastframe events', async ({ page, server, trace }) => {
+  test.skip(trace === 'on', 'trace=on enables screencast frame events');
+
+  const frames = [];
+  page.screencast().on('screencastframe', frame => frames.push(frame));
+
+  await page.video().start({ size: { width: 320, height: 240 } });
+  await page.goto(server.EMPTY_PAGE);
+  await page.evaluate(() => document.body.style.backgroundColor = 'red');
+  await rafraf(page, 100);
+  await page.video().stop();
+
+  expect(frames).toHaveLength(0);
+});
+
+function jpegDimensions(buffer: Buffer): { width: number, height: number } {
+  let i = 2; // skip SOI marker (FF D8)
+  while (i < buffer.length - 8) {
+    if (buffer[i] !== 0xFF)
+      break;
+    const marker = buffer[i + 1];
+    const segmentLength = buffer.readUInt16BE(i + 2);
+    // SOF markers: C0 (baseline), C2 (progressive), C1, C3, C5-C7, C9-CB, CD-CF
+    if ((marker >= 0xC0 && marker <= 0xC3) || (marker >= 0xC5 && marker <= 0xC7) ||
+        (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
+      const height = buffer.readUInt16BE(i + 5);
+      const width = buffer.readUInt16BE(i + 7);
+      return { width, height };
+    }
+    i += 2 + segmentLength;
+  }
+  throw new Error('Could not parse JPEG dimensions');
+}
diff --git a/tests/library/video.spec.ts b/tests/library/video.spec.ts
index da6ddf7a8e91f..2e9242b319a20 100644
--- a/tests/library/video.spec.ts
+++ b/tests/library/video.spec.ts
@@ -896,91 +896,6 @@ it.describe('screencast', () => {
     expectFrames(videoPath, size, isAlmostWhite);
   });
 
-  it('inspector.startScreencast emits screencastframe events', async ({ browser, server, trace }) => {
-    it.skip(trace === 'on', 'trace=on has different screencast image configuration');
-    const context = await browser.newContext({ viewport: { width: 1000, height: 400 } });
-    const page = await context.newPage();
-
-    const frames: { data: Buffer }[] = [];
-    page.inspector().on('screencastframe', frame => frames.push(frame));
-
-    const maxSize = { width: 500, height: 400 };
-    await page.inspector().startScreencast({ maxSize });
-    await page.goto(server.EMPTY_PAGE);
-    await page.evaluate(() => document.body.style.backgroundColor = 'red');
-    await rafraf(page, 100);
-    await page.inspector().stopScreencast();
-
-    expect(frames.length).toBeGreaterThan(0);
-    for (const frame of frames) {
-      // Each frame must be a valid JPEG (starts with FF D8)
-      expect(frame.data[0]).toBe(0xff);
-      expect(frame.data[1]).toBe(0xd8);
-      const { width, height } = jpegDimensions(frame.data);
-      // Frame should be scaled down to fit the maximum size.
-      expect(width).toBe(500);
-      expect(height).toBe(200);
-    }
-
-    await context.close();
-  });
-
-  it('startScreencast throws if already running', async ({ browser, trace }) => {
-    it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
-    const size = { width: 500, height: 400 };
-    const context = await browser.newContext({ viewport: size });
-    const page = await context.newPage();
-
-    await page.inspector().startScreencast({ maxSize: size });
-    await expect(page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running');
-
-    await page.inspector().stopScreencast();
-    await context.close();
-  });
-
-  it('startScreencast allows restart with different options after stop', async ({ browser, trace }) => {
-    it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
-    const context = await browser.newContext({ viewport: { width: 500, height: 400 } });
-    const page = await context.newPage();
-
-    await page.inspector().startScreencast({ maxSize: { width: 500, height: 400 } });
-    await page.inspector().stopScreencast();
-    // Different options should succeed once the previous screencast is stopped.
-    await page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } });
-    await page.inspector().stopScreencast();
-    await context.close();
-  });
-
-  it('startScreencast throws when video recording is running with different params', async ({ browser, trace }) => {
-    it.skip(trace === 'on', 'trace=on enables screencast with different options');
-
-    const videoSize = { width: 500, height: 400 };
-    const context = await browser.newContext({ viewport: videoSize });
-    const page = await context.newPage();
-
-    await page.video().start({ size: videoSize });
-    await expect(page.inspector().startScreencast({ maxSize: { width: 320, height: 240 } })).rejects.toThrow('Screencast is already running with different options');
-
-    await page.video().stop();
-    await context.close();
-  });
-
-  it('video.start does not emit screencastframe events', async ({ page, server, trace }) => {
-    it.skip(trace === 'on', 'trace=on enables screencast frame events');
-
-    const frames = [];
-    page.inspector().on('screencastframe', frame => frames.push(frame));
-
-    await page.video().start({ size: { width: 320, height: 240 } });
-    await page.goto(server.EMPTY_PAGE);
-    await page.evaluate(() => document.body.style.backgroundColor = 'red');
-    await rafraf(page, 100);
-    await page.video().stop();
-
-    expect(frames).toHaveLength(0);
-  });
 });
 
 it('should saveAs video', async ({ browser }, testInfo) => {
@@ -1004,22 +919,3 @@ it('should saveAs video', async ({ browser }, testInfo) => {
   await page.video().saveAs(saveAsPath);
   expect(fs.existsSync(saveAsPath)).toBeTruthy();
 });
-
-function jpegDimensions(buffer: Buffer): { width: number, height: number } {
-  let i = 2; // skip SOI marker (FF D8)
-  while (i < buffer.length - 8) {
-    if (buffer[i] !== 0xFF)
-      break;
-    const marker = buffer[i + 1];
-    const segmentLength = buffer.readUInt16BE(i + 2);
-    // SOF markers: C0 (baseline), C2 (progressive), C1, C3, C5-C7, C9-CB, CD-CF
-    if ((marker >= 0xC0 && marker <= 0xC3) || (marker >= 0xC5 && marker <= 0xC7) ||
-        (marker >= 0xC9 && marker <= 0xCB) || (marker >= 0xCD && marker <= 0xCF)) {
-      const height = buffer.readUInt16BE(i + 5);
-      const width = buffer.readUInt16BE(i + 7);
-      return { width, height };
-    }
-    i += 2 + segmentLength;
-  }
-  throw new Error('Could not parse JPEG dimensions');
-}
diff --git a/tests/mcp/cli-fixtures.ts b/tests/mcp/cli-fixtures.ts
index a6a05ef7f33d2..300fe379590b0 100644
--- a/tests/mcp/cli-fixtures.ts
+++ b/tests/mcp/cli-fixtures.ts
@@ -64,6 +64,7 @@ export const test = baseTest.extend<{
 
 function cliEnv() {
   return {
+    PLAYWRIGHT_SERVER_REGISTRY: test.info().outputPath('registry'),
     PLAYWRIGHT_DAEMON_SESSION_DIR: test.info().outputPath('daemon'),
     PLAYWRIGHT_DAEMON_SOCKETS_DIR: path.join(test.info().project.outputDir, 'ds'),
   };
diff --git a/tests/mcp/http.spec.ts b/tests/mcp/http.spec.ts
index e3d997c1c8a52..1e0b9765b9cf5 100644
--- a/tests/mcp/http.spec.ts
+++ b/tests/mcp/http.spec.ts
@@ -236,33 +236,8 @@ test('http transport browser lifecycle (persistent)', async ({ serverEndpoint, s
   });
 });
 
-test('http transport browser lifecycle (persistent, multiclient)', async ({ serverEndpoint, server }) => {
-  const { url } = await serverEndpoint();
-
-  const transport1 = new StreamableHTTPClientTransport(new URL('/mcp', url));
-  const client1 = new Client({ name: 'test', version: '1.0.0' });
-  await client1.connect(transport1);
-  await client1.callTool({
-    name: 'browser_navigate',
-    arguments: { url: server.HELLO_WORLD },
-  });
-
-  const transport2 = new StreamableHTTPClientTransport(new URL('/mcp', url));
-  const client2 = new Client({ name: 'test', version: '1.0.0' });
-  await client2.connect(transport2);
-  const response = await client2.callTool({
-    name: 'browser_navigate',
-    arguments: { url: server.HELLO_WORLD },
-  });
-  expect(response.isError).toBe(true);
-  expect(response.content?.[0].text).toContain('use --isolated to run multiple instances of the same browser');
-
-  await client1.close();
-  await client2.close();
-});
-
 test('http transport shared context', async ({ serverEndpoint, server }) => {
-  const { url, stderr } = await serverEndpoint({ args: ['--shared-browser-context'] });
+  const { url, stderr } = await serverEndpoint();
 
   // Create first client and navigate
   const transport1 = new StreamableHTTPClientTransport(new URL('/mcp', url));
diff --git a/tests/mcp/sse.spec.ts b/tests/mcp/sse.spec.ts
index 2785a0c81e9bb..322d5bef711d6 100644
--- a/tests/mcp/sse.spec.ts
+++ b/tests/mcp/sse.spec.ts
@@ -185,33 +185,8 @@ test('sse transport browser lifecycle (persistent)', async ({ serverEndpoint, se
   });
 });
 
-test('sse transport browser lifecycle (persistent, multiclient)', async ({ serverEndpoint, server }) => {
-  const { url } = await serverEndpoint();
-
-  const transport1 = new SSEClientTransport(new URL('/sse', url));
-  const client1 = new Client({ name: 'test', version: '1.0.0' });
-  await client1.connect(transport1);
-  await client1.callTool({
-    name: 'browser_navigate',
-    arguments: { url: server.HELLO_WORLD },
-  });
-
-  const transport2 = new SSEClientTransport(new URL('/sse', url));
-  const client2 = new Client({ name: 'test', version: '1.0.0' });
-  await client2.connect(transport2);
-  const response = await client2.callTool({
-    name: 'browser_navigate',
-    arguments: { url: server.HELLO_WORLD },
-  });
-  expect(response.isError).toBe(true);
-  expect(response.content?.[0].text).toContain('use --isolated to run multiple instances of the same browser');
-
-  await client1.close();
-  await client2.close();
-});
-
 test('sse transport shared context', async ({ serverEndpoint, server }) => {
-  const { url, stderr } = await serverEndpoint({ args: ['--shared-browser-context'] });
+  const { url, stderr } = await serverEndpoint();
 
   // Create first client and navigate
   const transport1 = new SSEClientTransport(new URL('/sse', url));