diff --git a/packages/extension/understudy/deepLocator.ts b/packages/extension/understudy/deepLocator.ts
index 7476794b7..f09be1b1e 100644
--- a/packages/extension/understudy/deepLocator.ts
+++ b/packages/extension/understudy/deepLocator.ts
@@ -129,14 +129,14 @@ export class DeepLocatorDelegate {
   }
 
   // Locator API delegates
-  async click(options?: { button?: MouseButton; clickCount?: number }) {
-    return (await this.real()).click(options);
+  async click(options?: { button?: MouseButton; clickCount?: number }, progress?: Progress) {
+    return (await this.real(progress)).click(options, progress);
   }
-  async count() {
-    return (await this.real()).count();
+  async count(progress?: Progress) {
+    return (await this.real(progress)).count(progress);
   }
-  async hover() {
-    return (await this.real()).hover();
+  async hover(progress?: Progress) {
+    return (await this.real(progress)).hover(progress);
   }
   async fill(value: string) {
     return (await this.real()).fill(value);
@@ -144,35 +144,35 @@ export class DeepLocatorDelegate {
   async type(text: string, options?: { delay?: number }) {
     return (await this.real()).type(text, options);
   }
-  async selectOption(values: string | string[]) {
-    return (await this.real()).selectOption(values);
+  async selectOption(values: string | string[], progress?: Progress) {
+    return (await this.real(progress)).selectOption(values, progress);
   }
-  async scrollTo(percent: number | string) {
-    return (await this.real()).scrollTo(percent);
+  async scrollTo(percent: number | string, progress?: Progress) {
+    return (await this.real(progress)).scrollTo(percent, progress);
   }
-  async isVisible() {
-    return (await this.real()).isVisible();
+  async isVisible(progress?: Progress) {
+    return (await this.real(progress)).isVisible(progress);
   }
-  async isChecked() {
-    return (await this.real()).isChecked();
+  async isChecked(progress?: Progress) {
+    return (await this.real(progress)).isChecked(progress);
   }
-  async inputValue() {
-    return (await this.real()).inputValue();
+  async inputValue(progress?: Progress) {
+    return (await this.real(progress)).inputValue(progress);
   }
-  async textContent() {
-    return (await this.real()).textContent();
+  async textContent(progress?: Progress) {
+    return (await this.real(progress)).textContent(progress);
   }
-  async innerHtml() {
-    return (await this.real()).innerHtml();
+  async innerHtml(progress?: Progress) {
+    return (await this.real(progress)).innerHtml(progress);
   }
-  async innerText() {
-    return (await this.real()).innerText();
+  async innerText(progress?: Progress) {
+    return (await this.real(progress)).innerText(progress);
   }
-  async centroid() {
-    return (await this.real()).centroid();
+  async centroid(progress?: Progress) {
+    return (await this.real(progress)).centroid(progress);
   }
-  async backendNodeId() {
-    return (await this.real()).backendNodeId();
+  async backendNodeId(progress?: Progress) {
+    return (await this.real(progress)).backendNodeId(progress);
   }
   async highlight(options?: {
     durationMs?: number;
@@ -181,13 +181,16 @@ export class DeepLocatorDelegate {
   }) {
     return (await this.real()).highlight(options);
   }
-  async sendClickEvent(options?: {
-    bubbles?: boolean;
-    cancelable?: boolean;
-    composed?: boolean;
-    detail?: number;
-  }) {
-    return (await this.real()).sendClickEvent(options);
+  async sendClickEvent(
+    options?: {
+      bubbles?: boolean;
+      cancelable?: boolean;
+      composed?: boolean;
+      detail?: number;
+    },
+    progress?: Progress,
+  ) {
+    return (await this.real(progress)).sendClickEvent(options, progress);
   }
   async setInputFiles(files: SetInputFilesArgument) {
     return (await this.real()).setInputFiles(files);
diff --git a/packages/extension/understudy/frameLocator.ts b/packages/extension/understudy/frameLocator.ts
index 99431d69d..e3dc40ca5 100644
--- a/packages/extension/understudy/frameLocator.ts
+++ b/packages/extension/understudy/frameLocator.ts
@@ -123,11 +123,14 @@ class LocatorDelegate {
   }
 
   // Locator API delegates
-  async click(options?: { button?: "left" | "right" | "middle"; clickCount?: number }) {
-    return (await this.real()).click(options);
+  async click(
+    options?: { button?: "left" | "right" | "middle"; clickCount?: number },
+    progress?: Progress,
+  ) {
+    return (await this.real(progress)).click(options, progress);
   }
-  async hover() {
-    return (await this.real()).hover();
+  async hover(progress?: Progress) {
+    return (await this.real(progress)).hover(progress);
   }
   async fill(value: string) {
     return (await this.real()).fill(value);
@@ -135,32 +138,32 @@ class LocatorDelegate {
   async type(text: string, options?: { delay?: number }) {
     return (await this.real()).type(text, options);
   }
-  async selectOption(values: string | string[]) {
-    return (await this.real()).selectOption(values);
+  async selectOption(values: string | string[], progress?: Progress) {
+    return (await this.real(progress)).selectOption(values, progress);
   }
-  async scrollTo(percent: number | string) {
-    return (await this.real()).scrollTo(percent);
+  async scrollTo(percent: number | string, progress?: Progress) {
+    return (await this.real(progress)).scrollTo(percent, progress);
   }
-  async isVisible() {
-    return (await this.real()).isVisible();
+  async isVisible(progress?: Progress) {
+    return (await this.real(progress)).isVisible(progress);
   }
-  async isChecked() {
-    return (await this.real()).isChecked();
+  async isChecked(progress?: Progress) {
+    return (await this.real(progress)).isChecked(progress);
   }
-  async inputValue() {
-    return (await this.real()).inputValue();
+  async inputValue(progress?: Progress) {
+    return (await this.real(progress)).inputValue(progress);
   }
-  async textContent() {
-    return (await this.real()).textContent();
+  async textContent(progress?: Progress) {
+    return (await this.real(progress)).textContent(progress);
   }
-  async innerHtml() {
-    return (await this.real()).innerHtml();
+  async innerHtml(progress?: Progress) {
+    return (await this.real(progress)).innerHtml(progress);
   }
-  async innerText() {
-    return (await this.real()).innerText();
+  async innerText(progress?: Progress) {
+    return (await this.real(progress)).innerText(progress);
   }
-  async count() {
-    return (await this.real()).count();
+  async count(progress?: Progress) {
+    return (await this.real(progress)).count(progress);
   }
   first(): LocatorDelegate {
     return this.nth(0);
diff --git a/packages/extension/understudy/locator.ts b/packages/extension/understudy/locator.ts
index 88fede0e0..d57aa77bd 100644
--- a/packages/extension/understudy/locator.ts
+++ b/packages/extension/understudy/locator.ts
@@ -1,5 +1,6 @@
 // lib/v3/understudy/locator.ts
 import { Protocol } from "devtools-protocol";
+import { isCdpClosedError } from "./cdp.js";
 import {
   assignFilePayloadsToInputElement,
   dispatchDomClick,
@@ -153,45 +154,67 @@ export class Locator {
    * Return the DOM backendNodeId for this locator's target element.
    * Useful for identity comparisons without needing element handles.
    */
-  async backendNodeId(): Promise<Protocol.DOM.BackendNodeId> {
+  async backendNodeId(progress?: Progress): Promise<Protocol.DOM.BackendNodeId> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      await session.send("DOM.enable").catch(() => {});
-      const { node } = await session.send<{ node: Protocol.DOM.Node }>("DOM.describeNode", {
-        objectId,
-      });
+      await runLocatorStep(progress, "enabling DOM", () =>
+        session.send("DOM.enable").catch((error) => {
+          progress?.throwIfStopped();
+          if (progress && isCdpClosedError(error)) throw error;
+        }),
+      );
+      const { node } = await runLocatorStep(progress, "describing element", () =>
+        session.send<{ node: Protocol.DOM.Node }>("DOM.describeNode", {
+          objectId,
+        }),
+      );
       return node.backendNodeId as Protocol.DOM.BackendNodeId;
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /** Return how many nodes the current selector resolves to. */
-  public async count(): Promise<number> {
+  public async count(progress?: Progress): Promise<number> {
     const session = this.frame.session;
-    await session.send("Runtime.enable");
-    await session.send("DOM.enable");
-    return this.selectorResolver.count(this.selectorQuery);
+    await runLocatorStep(progress, "enabling runtime", () => session.send("Runtime.enable"));
+    await runLocatorStep(progress, "enabling DOM", () => session.send("DOM.enable"));
+    return this.selectorResolver.count(this.selectorQuery, progress);
   }
 
   /**
    * Return the center of the element's bounding box in the owning frame's viewport
    * (CSS pixels), rounded to integers. Scrolls into view best-effort.
    */
-  public async centroid(): Promise<{ x: number; y: number }> {
+  public async centroid(progress?: Progress): Promise<{ x: number; y: number }> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      await session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch(() => {});
-      const box = await session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
-        objectId,
-      });
+      await runLocatorStep(progress, "scrolling into view", () =>
+        session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch((error) => {
+          progress?.throwIfStopped();
+          if (progress && isCdpClosedError(error)) throw error;
+        }),
+      );
+      const box = await runLocatorStep(progress, "reading element geometry", () =>
+        session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
+          objectId,
+        }),
+      );
       if (!box.model) throw new Error(`Element not visible (no box model): ${this.selector}`);
       const { cx, cy } = this.centerFromBoxContent(box.model.content);
       return { x: Math.round(cx), y: Math.round(cy) };
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -271,26 +294,39 @@ export class Locator {
    * Move the mouse cursor to the element's visual center without clicking.
    * - Scrolls into view best-effort, resolves geometry, then dispatches a mouse move.
    */
-  async hover(): Promise<void> {
+  async hover(progress?: Progress): Promise<void> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      await session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch(() => {});
+      await runLocatorStep(progress, "scrolling into view", () =>
+        session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch((error) => {
+          progress?.throwIfStopped();
+          if (progress && isCdpClosedError(error)) throw error;
+        }),
+      );
 
-      const box = await session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
-        objectId,
-      });
+      const box = await runLocatorStep(progress, "reading element geometry", () =>
+        session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
+          objectId,
+        }),
+      );
       if (!box.model) throw new Error(`Element not visible (no box model): ${this.selector}`);
       const { cx, cy } = this.centerFromBoxContent(box.model.content);
 
-      await session.send<never>("Input.dispatchMouseEvent", {
-        type: "mouseMoved",
-        x: cx,
-        y: cy,
-        button: "none",
-      } as Protocol.Input.DispatchMouseEventRequest);
+      await runLocatorStep(progress, "dispatching mouse events", () =>
+        session.send<never>("Input.dispatchMouseEvent", {
+          type: "mouseMoved",
+          x: cx,
+          y: cy,
+          button: "none",
+        } as Protocol.Input.DispatchMouseEventRequest),
+      );
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -302,21 +338,28 @@ export class Locator {
    *  3) Read geometry via `DOM.getBoxModel({ objectId })` → compute a center point.
    *  4) Synthesize mouse press + release via `Input.dispatchMouseEvent`.
    */
-  async click(options?: { button?: MouseButton; clickCount?: number }): Promise<void> {
+  async click(
+    options?: { button?: MouseButton; clickCount?: number },
+    progress?: Progress,
+  ): Promise<void> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
 
     const button = options?.button ?? "left";
     const clickCount = options?.clickCount ?? 1;
 
     try {
       // Scroll into view using objectId (avoids frontend nodeId dependence)
-      await session.send("DOM.scrollIntoViewIfNeeded", { objectId });
+      await runLocatorStep(progress, "scrolling into view", () =>
+        session.send("DOM.scrollIntoViewIfNeeded", { objectId }),
+      );
 
       // Get geometry using objectId
-      const box = await session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
-        objectId,
-      });
+      const box = await runLocatorStep(progress, "reading element geometry", () =>
+        session.send<Protocol.DOM.GetBoxModelResponse>("DOM.getBoxModel", {
+          objectId,
+        }),
+      );
       if (!box.model) throw new Error(`Element not visible (no box model): ${this.selector}`);
       const { cx, cy } = this.centerFromBoxContent(box.model.content);
 
@@ -324,43 +367,47 @@ export class Locator {
       // from network/CPU jitter between round trips.
       const dispatches: Array<Promise<unknown>> = [];
       dispatches.push(
-        session.send<never>("Input.dispatchMouseEvent", {
-          type: "mouseMoved",
-          x: cx,
-          y: cy,
-          button: "none",
-        } as Protocol.Input.DispatchMouseEventRequest),
-      );
-
-      for (let i = 1; i <= clickCount; i++) {
-        dispatches.push(
+        runLocatorStep(progress, "dispatching mouse events", () =>
           session.send<never>("Input.dispatchMouseEvent", {
-            type: "mousePressed",
+            type: "mouseMoved",
             x: cx,
             y: cy,
-            button,
-            clickCount: i,
+            button: "none",
           } as Protocol.Input.DispatchMouseEventRequest),
+        ),
+      );
+
+      for (let i = 1; i <= clickCount; i++) {
+        dispatches.push(
+          runLocatorStep(progress, "dispatching mouse events", () =>
+            session.send<never>("Input.dispatchMouseEvent", {
+              type: "mousePressed",
+              x: cx,
+              y: cy,
+              button,
+              clickCount: i,
+            } as Protocol.Input.DispatchMouseEventRequest),
+          ),
         );
         dispatches.push(
-          session.send<never>("Input.dispatchMouseEvent", {
-            type: "mouseReleased",
-            x: cx,
-            y: cy,
-            button,
-            clickCount: i,
-          } as Protocol.Input.DispatchMouseEventRequest),
+          runLocatorStep(progress, "dispatching mouse events", () =>
+            session.send<never>("Input.dispatchMouseEvent", {
+              type: "mouseReleased",
+              x: cx,
+              y: cy,
+              button,
+              clickCount: i,
+            } as Protocol.Input.DispatchMouseEventRequest),
+          ),
         );
       }
       await Promise.all(dispatches);
     } finally {
-      // release the element handle
-      try {
-        await session.send<never>("Runtime.releaseObject", { objectId });
-      } catch {
-        // If the context navigated or was destroyed (e.g., link opens new tab),
-        // releaseObject may fail with -32000. Ignore as best-effort cleanup.
-      }
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -369,32 +416,46 @@ export class Locator {
    * - Does not synthesize real pointer input; directly dispatches an event.
    * - Useful for elements that rely on click handlers without needing hit-testing.
    */
-  async sendClickEvent(options?: {
-    bubbles?: boolean;
-    cancelable?: boolean;
-    composed?: boolean;
-    detail?: number;
-  }): Promise<void> {
+  async sendClickEvent(
+    options?: {
+      bubbles?: boolean;
+      cancelable?: boolean;
+      composed?: boolean;
+      detail?: number;
+    },
+    progress?: Progress,
+  ): Promise<void> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     const bubbles = options?.bubbles ?? true;
     const cancelable = options?.cancelable ?? true;
     const composed = options?.composed ?? true;
     const detail = options?.detail ?? 1;
     try {
-      await session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch(() => {});
-      await session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
-        objectId,
-        functionDeclaration: dispatchDomClick.toString(),
-        arguments: [
-          {
-            value: { bubbles, cancelable, composed, detail },
-          },
-        ],
-        returnByValue: true,
-      });
+      await runLocatorStep(progress, "scrolling into view", () =>
+        session.send("DOM.scrollIntoViewIfNeeded", { objectId }).catch((error) => {
+          progress?.throwIfStopped();
+          if (progress && isCdpClosedError(error)) throw error;
+        }),
+      );
+      await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
+          objectId,
+          functionDeclaration: dispatchDomClick.toString(),
+          arguments: [
+            {
+              value: { bubbles, cancelable, composed, detail },
+            },
+          ],
+          returnByValue: true,
+        }),
+      );
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -403,18 +464,24 @@ export class Locator {
    * - If the element is <html> or <body>, scrolls the window/document.
    * - Otherwise, scrolls the element itself via element.scrollTo.
    */
-  async scrollTo(percent: number | string): Promise<void> {
+  async scrollTo(percent: number | string, progress?: Progress): Promise<void> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      await session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
-        objectId,
-        functionDeclaration: scrollElementToPercent.toString(),
-        arguments: [{ value: percent as unknown as number }],
-        returnByValue: true,
-      });
+      await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
+          objectId,
+          functionDeclaration: scrollElementToPercent.toString(),
+          arguments: [{ value: percent as unknown as number }],
+          returnByValue: true,
+        }),
+      );
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      const release = () =>
+        session.send<never>("Runtime.releaseObject", { objectId }).catch(() => {});
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -582,46 +649,50 @@ export class Locator {
    * Select one or more options on a `<select>` element.
    * Returns the values actually selected after the operation.
    */
-  async selectOption(values: string | string[]): Promise<string[]> {
+  async selectOption(values: string | string[], progress?: Progress): Promise<string[]> {
     const session = this.frame.session;
     const desired = Array.isArray(values) ? values : [values];
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
 
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: selectElementOptions.toString(),
           arguments: [{ value: desired }],
           returnByValue: true,
-        },
+        }),
       );
 
       return (res.result.value as string[]) ?? [];
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /**
    * Return true if the element is attached and visible (rough heuristic).
    */
-  async isVisible(): Promise<boolean> {
+  async isVisible(progress?: Progress): Promise<boolean> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: isElementVisible.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return Boolean(res.result.value);
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
@@ -629,105 +700,115 @@ export class Locator {
    * Return true if the element is an input[type=checkbox|radio] and is checked.
    * Also considers aria-checked for ARIA widgets.
    */
-  async isChecked(): Promise<boolean> {
+  async isChecked(progress?: Progress): Promise<boolean> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: isElementChecked.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return Boolean(res.result.value);
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /**
    * Return the element's input value (for input/textarea/select/contenteditable).
    */
-  async inputValue(): Promise<string> {
+  async inputValue(progress?: Progress): Promise<string> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: readElementInputValue.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return String(res.result.value ?? "");
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /**
    * Return the element's textContent (raw, not innerText).
    */
-  async textContent(): Promise<string> {
+  async textContent(progress?: Progress): Promise<string> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: readElementTextContent.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return String(res.result.value ?? "");
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /**
    * Return the element's innerHTML string.
    */
-  async innerHtml(): Promise<string> {
+  async innerHtml(progress?: Progress): Promise<string> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: readElementInnerHTML.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return String(res.result.value ?? "");
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
   /**
    * Return the element's innerText (layout-aware, visible text).
    */
-  async innerText(): Promise<string> {
+  async innerText(progress?: Progress): Promise<string> {
     const session = this.frame.session;
-    const { objectId } = await this.resolveNode();
+    const { objectId } = await this.resolveNode(progress);
     try {
-      const res = await session.send<Protocol.Runtime.CallFunctionOnResponse>(
-        "Runtime.callFunctionOn",
-        {
+      const res = await runLocatorStep(progress, "evaluating element", () =>
+        session.send<Protocol.Runtime.CallFunctionOnResponse>("Runtime.callFunctionOn", {
           objectId,
           functionDeclaration: readElementInnerText.toString(),
           returnByValue: true,
-        },
+        }),
       );
       return String(res.result.value ?? "");
     } finally {
-      await session.send<never>("Runtime.releaseObject", { objectId });
+      const release = () => session.send<never>("Runtime.releaseObject", { objectId });
+      if (progress) await progress.cleanup(release);
+      else await release();
+      progress?.throwIfStopped();
     }
   }
 
diff --git a/packages/extension/understudy/locatorActions.test.ts b/packages/extension/understudy/locatorActions.test.ts
new file mode 100644
index 000000000..f9688286b
--- /dev/null
+++ b/packages/extension/understudy/locatorActions.test.ts
@@ -0,0 +1,364 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { TimeoutError } from "../errors.js";
+import type { Frame } from "./frame.js";
+import type { Page } from "./page.js";
+import { DeepLocatorDelegate } from "./deepLocator.js";
+import { frameLocatorFromFrame } from "./frameLocator.js";
+import { executionContexts } from "./executionContextRegistry.js";
+import { Locator } from "./locator.js";
+import { Progress, runWithProgress } from "./progress.js";
+
+const actions = [
+  ["click", [{ button: "right", clickCount: 2 }]],
+  ["hover", []],
+  ["selectOption", [["first", "second"]]],
+  ["scrollTo", [75]],
+  ["sendClickEvent", [{ bubbles: false, detail: 2 }]],
+  ["centroid", []],
+  ["backendNodeId", []],
+  ["count", []],
+  ["isVisible", []],
+  ["isChecked", []],
+  ["inputValue", []],
+  ["innerText", []],
+  ["innerHtml", []],
+  ["textContent", []],
+] as const;
+type Action = (typeof actions)[number][0];
+
+function createLocator(selector = "button") {
+  const send = vi.fn(async (method: string, _params?: object): Promise<unknown> => {
+    if (method === "DOM.getBoxModel") return { model: { content: [0, 0, 10, 0, 10, 10, 0, 10] } };
+    if (method === "DOM.describeNode") return { node: { backendNodeId: 1 } };
+    if (method === "Runtime.evaluate")
+      return { result: { value: selector.startsWith("text=") ? { count: 2 } : 2 } };
+    if (method === "Runtime.callFunctionOn") return { result: { value: "value" } };
+    return {};
+  });
+  const frame = { frameId: "root", session: { send } } as unknown as Frame;
+  const locator = new Locator(frame, selector);
+  const resolveNode = vi
+    .spyOn(locator, "resolveNode")
+    .mockResolvedValue({ objectId: "node", nodeId: 1 });
+  const readiness = vi.spyOn(executionContexts, "waitForLocatorWorld").mockResolvedValue({
+    kind: "extension",
+    contextId: 1,
+    capabilities: { closedShadowRoots: true },
+  });
+  return { locator, frame, resolveNode, readiness, send };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe.each(["direct", "deep", "frame"] as const)("%s locator progress forwarding", (kind) => {
+  const supported = actions.filter(
+    ([method]) =>
+      kind !== "frame" || !["sendClickEvent", "centroid", "backendNodeId"].includes(method),
+  );
+
+  it.each(supported)("passes the caller's progress through %s", async (method, args) => {
+    const { locator, frame, resolveNode } = createLocator();
+    const delegate =
+      kind === "direct"
+        ? undefined
+        : kind === "deep"
+          ? new DeepLocatorDelegate({} as Page, frame, "button")
+          : frameLocatorFromFrame({} as Page, frame, "iframe").locator("button");
+    const real = delegate ? vi.spyOn(delegate, "real").mockResolvedValue(locator) : undefined;
+    const target: Partial<Pick<Locator, Action>> = delegate ?? locator;
+    const action = vi.spyOn(locator, method);
+    const count = vi.spyOn(locator.selectorResolver, "count");
+
+    await runWithProgress({ name: method, timeout: 1000 }, async (progress) => {
+      await Reflect.apply(target[method]!, target, [...args, progress]);
+      if (real) expect(real).toHaveBeenCalledExactlyOnceWith(progress);
+      expect(action).toHaveBeenCalledExactlyOnceWith(...args, progress);
+      if (method === "count") {
+        expect(count).toHaveBeenCalledExactlyOnceWith(locator.selectorQuery, progress);
+        expect(resolveNode).not.toHaveBeenCalled();
+      } else {
+        expect(resolveNode).toHaveBeenCalledExactlyOnceWith(progress);
+      }
+    });
+  });
+});
+
+describe("counting progress forwarding", () => {
+  it.each([
+    ["button", "countCss"],
+    ["text=button", "countText"],
+    ["xpath=//button", "countXPath"],
+  ] as const)("passes progress through %s counting & readiness", async (selector, method) => {
+    const { locator, frame, readiness } = createLocator(selector);
+    const count = vi.spyOn(locator.selectorResolver, method);
+    const evaluate = vi.spyOn(locator.selectorResolver, "evaluateCount");
+
+    await runWithProgress({ name: "count", timeout: 1000 }, async (progress) => {
+      await expect(locator.count(progress)).resolves.toBe(2);
+      expect(count).toHaveBeenCalledExactlyOnceWith(locator.selectorQuery.value, progress);
+      expect(readiness).toHaveBeenCalledExactlyOnceWith(
+        frame.session,
+        frame.frameId,
+        1000,
+        progress,
+      );
+      if (method === "countCss")
+        expect(evaluate).toHaveBeenCalledExactlyOnceWith(expect.any(String), 1, progress);
+    });
+  });
+});
+
+function deferred() {
+  let resolve!: (value: unknown) => void;
+  const promise = new Promise<unknown>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+describe("locator action deadlines", () => {
+  const contexts: Progress[] = [];
+  const createProgress = (timeout = 100) => {
+    const progress = new Progress("action", timeout);
+    contexts.push(progress);
+    return progress;
+  };
+  beforeEach(() => vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "performance"] }));
+  afterEach(() => {
+    contexts.splice(0).forEach((progress) => progress.dispose());
+    expect(vi.getTimerCount()).toBe(0);
+    vi.useRealTimers();
+  });
+
+  const stalledCommands: Partial<Record<Action, string[]>> = {
+    click: ["DOM.scrollIntoViewIfNeeded", "DOM.getBoxModel", "Input.dispatchMouseEvent"],
+    hover: ["DOM.getBoxModel", "Input.dispatchMouseEvent"],
+    centroid: ["DOM.getBoxModel"],
+    backendNodeId: ["DOM.enable", "DOM.describeNode"],
+    count: ["Runtime.enable", "DOM.enable", "Runtime.evaluate"],
+  };
+  it.each(
+    actions.flatMap(([method, args]) =>
+      (stalledCommands[method] ?? ["Runtime.callFunctionOn"]).map((command) => ({
+        method,
+        args,
+        command,
+      })),
+    ),
+  )(
+    "bounds $method waiting for $command & ignores its late response",
+    async ({ method, args, command }) => {
+      const { locator, send } = createLocator();
+      const gate = deferred();
+      const respond = send.getMockImplementation()!;
+      send.mockImplementation((name) => (name === command ? gate.promise : respond(name)));
+      const pending = Reflect.apply(locator[method], locator, [...args, createProgress()]);
+      const rejected = expect(pending).rejects.toThrow(TimeoutError);
+      await vi.advanceTimersByTimeAsync(100);
+      await rejected;
+      const sent = send.mock.calls.filter(([name]) => name !== "Runtime.releaseObject").length;
+      gate.resolve(await respond(command));
+      await vi.advanceTimersByTimeAsync(0);
+      expect(send.mock.calls.filter(([name]) => name !== "Runtime.releaseObject")).toHaveLength(
+        sent,
+      );
+      if (method !== "count")
+        expect(send).toHaveBeenCalledWith("Runtime.releaseObject", { objectId: "node" });
+      if (command !== "Input.dispatchMouseEvent")
+        expect(send.mock.calls.some(([name]) => name === "Input.dispatchMouseEvent")).toBe(false);
+    },
+  );
+
+  it.each(["click", "count"] as const)("does not start %s after expiry", async (method) => {
+    const { locator, send } = createLocator();
+    const progress = createProgress();
+    vi.spyOn(performance, "now").mockReturnValue(101);
+    const pending =
+      method === "click" ? locator.click(undefined, progress) : locator.count(progress);
+    await expect(pending).rejects.toThrow(TimeoutError);
+    expect(send.mock.calls.filter(([name]) => name !== "Runtime.releaseObject")).toHaveLength(0);
+  });
+
+  it.each([
+    ["isVisible", false],
+    ["isChecked", false],
+    ["inputValue", ""],
+    ["innerText", ""],
+    ["innerHtml", ""],
+    ["textContent", ""],
+  ] as const)("preserves an empty %s result", async (method, expected) => {
+    const { locator, send } = createLocator();
+    send.mockResolvedValue({ result: { value: null } });
+    await expect(locator[method](createProgress())).resolves.toBe(expected);
+  });
+
+  it("uses only the remaining budget after deep resolution", async () => {
+    const { locator, frame, send } = createLocator();
+    const delegate = new DeepLocatorDelegate({} as Page, frame, "button");
+    vi.spyOn(delegate, "real").mockImplementation(async (progress) => {
+      await progress!.delay(60);
+      return locator;
+    });
+    const gate = deferred();
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation((name) => (name === "DOM.getBoxModel" ? gate.promise : respond(name)));
+    const progress = createProgress();
+    const pending = delegate.click(undefined, progress);
+    const rejected = expect(pending).rejects.toThrow(TimeoutError);
+    await vi.advanceTimersByTimeAsync(60);
+    expect(progress.remainingMs()).toBe(40);
+    await vi.advanceTimersByTimeAsync(40);
+    await rejected;
+    gate.resolve(await respond("DOM.getBoxModel"));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(send.mock.calls.some(([name]) => name === "Input.dispatchMouseEvent")).toBe(false);
+  });
+
+  it.each([undefined, 0, 100])("preserves the click burst with timeout %s", async (timeout) => {
+    const { locator, send } = createLocator();
+    const gate = deferred();
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation((name) =>
+      name === "Input.dispatchMouseEvent" ? gate.promise : respond(name),
+    );
+    const pending = locator.click(
+      { button: "right", clickCount: 2 },
+      timeout === undefined ? undefined : createProgress(timeout),
+    );
+    await vi.advanceTimersByTimeAsync(0);
+    const events = send.mock.calls.filter(([name]) => name === "Input.dispatchMouseEvent");
+    expect(events.map(([, params]) => params)).toEqual([
+      { type: "mouseMoved", x: 5, y: 5, button: "none" },
+      { type: "mousePressed", x: 5, y: 5, button: "right", clickCount: 1 },
+      { type: "mouseReleased", x: 5, y: 5, button: "right", clickCount: 1 },
+      { type: "mousePressed", x: 5, y: 5, button: "right", clickCount: 2 },
+      { type: "mouseReleased", x: 5, y: 5, button: "right", clickCount: 2 },
+    ]);
+    gate.resolve({});
+    await pending;
+  });
+
+  it("stops dispatching a click burst once the deadline passes", async () => {
+    const { locator, send } = createLocator();
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation(async (name) => {
+      if (name === "Input.dispatchMouseEvent") vi.spyOn(performance, "now").mockReturnValue(101);
+      return respond(name);
+    });
+    await expect(locator.click({ clickCount: 2 }, createProgress())).rejects.toThrow(TimeoutError);
+    expect(send.mock.calls.filter(([name]) => name === "Input.dispatchMouseEvent")).toHaveLength(1);
+  });
+
+  it.each(["ordinary", "closed", "expired"])("handles a %s scrolling error", async (kind) => {
+    const { locator, send } = createLocator();
+    const error = new Error(kind === "closed" ? "CDP connection closed: gone" : "no layout object");
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation(async (name) => {
+      if (name === "DOM.scrollIntoViewIfNeeded") {
+        if (kind === "expired") vi.spyOn(performance, "now").mockReturnValue(101);
+        throw error;
+      }
+      return respond(name);
+    });
+    const pending = locator.hover(createProgress());
+    if (kind === "ordinary") await expect(pending).resolves.toBeUndefined();
+    else if (kind === "closed") await expect(pending).rejects.toBe(error);
+    else await expect(pending).rejects.toThrow(TimeoutError);
+    expect(send.mock.calls.some(([name]) => name === "Input.dispatchMouseEvent")).toBe(
+      kind === "ordinary",
+    );
+  });
+
+  it.each(["button", "text=button", "xpath=//button"])(
+    "preserves expiry & closure in %s counts",
+    async (selector) => {
+      const { locator, send } = createLocator(selector);
+      const closed = new Error("No Page found for target closed before CDP response: gone");
+      const respond = send.getMockImplementation()!;
+      send.mockImplementation(async (name) => {
+        if (name === "Runtime.evaluate") throw closed;
+        return respond(name);
+      });
+      await expect(locator.count(createProgress())).rejects.toBe(closed);
+      const progress = createProgress();
+      send.mockImplementation(async (name) => {
+        if (name === "Runtime.evaluate") {
+          vi.spyOn(performance, "now").mockReturnValue(101);
+          throw new Error("context gone");
+        }
+        return respond(name);
+      });
+      await expect(locator.count(progress)).rejects.toThrow(TimeoutError);
+    },
+  );
+
+  it.each(["button", "text=button", "xpath=//button"])(
+    "preserves an empty %s count",
+    async (selector) => {
+      const { locator, send } = createLocator(selector);
+      send.mockResolvedValue({ result: { value: 0 } });
+      await expect(locator.count(createProgress())).resolves.toBe(0);
+    },
+  );
+
+  it.each([false, true])(
+    "preserves errors & checks expiry after cleanup (expired: %s)",
+    async (expired) => {
+      const { locator, send } = createLocator();
+      const primary = new Error("evaluation failed");
+      const respond = send.getMockImplementation()!;
+      send.mockImplementation(async (name) => {
+        if (name === "Runtime.callFunctionOn" && !expired) throw primary;
+        if (name === "Runtime.releaseObject") {
+          if (expired) vi.spyOn(performance, "now").mockReturnValue(101);
+          throw new Error("cleanup failed");
+        }
+        return respond(name);
+      });
+      const pending = locator.innerText(createProgress());
+      if (expired) await expect(pending).rejects.toThrow(TimeoutError);
+      else await expect(pending).rejects.toBe(primary);
+    },
+  );
+
+  it("bounds stalled cleanup without holding the outer caller", async () => {
+    const { locator, send } = createLocator();
+    const gate = deferred();
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation((name) =>
+      name === "Runtime.releaseObject" ? gate.promise : respond(name),
+    );
+    let finished = false;
+    const pending = runWithProgress({ name: "read", timeout: 100 }, async (progress) => {
+      try {
+        return await locator.innerText(progress);
+      } finally {
+        finished = true;
+      }
+    });
+    const rejected = expect(pending).rejects.toThrow(TimeoutError);
+    await vi.advanceTimersByTimeAsync(100);
+    await rejected;
+    expect(finished).toBe(false);
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(finished).toBe(true);
+    gate.resolve({});
+    await vi.advanceTimersByTimeAsync(0);
+  });
+
+  it("keeps concurrent calls independent & allows an unlimited read to finish", async () => {
+    const { locator, send } = createLocator();
+    const gate = deferred();
+    const respond = send.getMockImplementation()!;
+    send.mockImplementation((name) =>
+      name === "Runtime.callFunctionOn" ? gate.promise : respond(name),
+    );
+    const first = locator.innerText(createProgress());
+    const second = locator.innerText(createProgress(0));
+    const rejected = expect(first).rejects.toThrow(TimeoutError);
+    await vi.advanceTimersByTimeAsync(100);
+    await rejected;
+    gate.resolve({ result: { value: "finished" } });
+    await expect(second).resolves.toBe("finished");
+  });
+});
diff --git a/packages/extension/understudy/locatorResolution.test.ts b/packages/extension/understudy/locatorResolution.test.ts
index 43be2cb55..b78442a81 100644
--- a/packages/extension/understudy/locatorResolution.test.ts
+++ b/packages/extension/understudy/locatorResolution.test.ts
@@ -245,6 +245,34 @@ describe("locator resolution deadlines", () => {
     expect(send).toHaveBeenCalledWith("Runtime.releaseObject", { objectId: "second" });
   });
 
+  it("reports expiry without waiting for a second stalled cleanup", async () => {
+    const { frame, send, respond } = createFrame("root");
+    const resolver = frame.locator("button").selectorResolver;
+    vi.spyOn(resolver, "resolveAll").mockResolvedValue([
+      { objectId: "unselected", nodeId: 1 },
+      { objectId: "selected", nodeId: 2 },
+    ]);
+    const gate = deferred();
+    send.mockImplementation((method, params) =>
+      method === "Runtime.releaseObject" ? gate.promise : respond(method, params),
+    );
+    const settled = vi.fn();
+    const pending = resolver.resolveAtIndex({ kind: "css", value: "button" }, 1, createProgress());
+    void pending.then(settled, settled);
+
+    try {
+      await vi.advanceTimersByTimeAsync(1000);
+      expect(settled).toHaveBeenCalledExactlyOnceWith(expect.any(TimeoutError));
+      expect(send.mock.calls.filter(([method]) => method === "Runtime.releaseObject")).toEqual([
+        ["Runtime.releaseObject", { objectId: "unselected" }],
+        ["Runtime.releaseObject", { objectId: "selected" }],
+      ]);
+    } finally {
+      gate.resolve({});
+      await vi.advanceTimersByTimeAsync(0);
+    }
+  });
+
   it("removes the main-world listener & timer when its caller expires", async () => {
     const { session, events } = createFrame("root", false);
     executionContexts.byFrame.delete(session);
diff --git a/packages/extension/understudy/selectorResolver.ts b/packages/extension/understudy/selectorResolver.ts
index 28f7e87bd..ca69ce88e 100644
--- a/packages/extension/understudy/selectorResolver.ts
+++ b/packages/extension/understudy/selectorResolver.ts
@@ -84,14 +84,15 @@ export class FrameSelectorResolver {
     }
   }
 
-  public async count(query: SelectorQuery): Promise<number> {
+  public async count(query: SelectorQuery, progress?: Progress): Promise<number> {
+    progress?.throwIfStopped();
     switch (query.kind) {
       case "css":
-        return this.countCss(query.value);
+        return this.countCss(query.value, progress);
       case "text":
-        return this.countText(query.value);
+        return this.countText(query.value, progress);
       case "xpath":
-        return this.countXPath(query.value);
+        return this.countXPath(query.value, progress);
       default:
         return 0;
     }
@@ -114,7 +115,7 @@ export class FrameSelectorResolver {
       try {
         progress.throwIfStopped();
       } catch (error) {
-        if (selected) await this.releaseNodes([selected], progress);
+        if (selected) void this.releaseNodes([selected], progress);
         throw error;
       }
     }
@@ -175,37 +176,41 @@ export class FrameSelectorResolver {
       );
   }
 
-  async countCss(selector: string): Promise<number> {
+  async countCss(selector: string, progress?: Progress): Promise<number> {
     const session = this.frame.session;
     const { contextId } = await executionContexts.waitForLocatorWorld(
       session,
       this.frame.frameId,
       1000,
+      progress,
     );
 
     const primaryExpr = buildLocatorInvocation("countCssMatchesPrimary", [
       JSON.stringify(selector),
     ]);
-    return this.evaluateCount(primaryExpr, contextId);
+    return this.evaluateCount(primaryExpr, contextId, progress);
   }
 
-  async countText(value: string): Promise<number> {
+  async countText(value: string, progress?: Progress): Promise<number> {
     const session = this.frame.session;
     const { contextId: ctxId } = await executionContexts.waitForLocatorWorld(
       session,
       this.frame.frameId,
       1000,
+      progress,
     );
 
     const expr = buildLocatorInvocation("countTextMatches", [JSON.stringify(value)]);
 
     try {
-      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
-        expression: expr,
-        contextId: ctxId,
-        returnByValue: true,
-        awaitPromise: true,
-      });
+      const evalRes = await runLocatorStep(progress, "counting elements", () =>
+        session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
+          expression: expr,
+          contextId: ctxId,
+          returnByValue: true,
+          awaitPromise: true,
+        }),
+      );
 
       if (evalRes.exceptionDetails) {
         const details = evalRes.exceptionDetails;
@@ -227,29 +232,34 @@ export class FrameSelectorResolver {
       const num = typeof data.count === "number" ? data.count : Number(data.count);
       if (!Number.isFinite(num)) return 0;
       return Math.max(0, Math.floor(num));
-    } catch {
+    } catch (error) {
+      progress?.throwIfStopped();
+      if (progress && isCdpClosedError(error)) throw error;
       return 0;
     }
   }
 
-  async countXPath(value: string): Promise<number> {
+  async countXPath(value: string, progress?: Progress): Promise<number> {
     const session = this.frame.session;
 
     const { contextId: ctxId } = await executionContexts.waitForLocatorWorld(
       session,
       this.frame.frameId,
       1000,
+      progress,
     );
 
     const expr = buildLocatorInvocation("countXPathMatchesMainWorld", [JSON.stringify(value)]);
 
     try {
-      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
-        expression: expr,
-        contextId: ctxId,
-        returnByValue: true,
-        awaitPromise: true,
-      });
+      const evalRes = await runLocatorStep(progress, "counting elements", () =>
+        session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
+          expression: expr,
+          contextId: ctxId,
+          returnByValue: true,
+          awaitPromise: true,
+        }),
+      );
 
       if (evalRes.exceptionDetails) {
         return 0;
@@ -261,7 +271,9 @@ export class FrameSelectorResolver {
           : Number(evalRes.result.value);
       if (!Number.isFinite(num)) return 0;
       return Math.max(0, Math.floor(num));
-    } catch {
+    } catch (error) {
+      progress?.throwIfStopped();
+      if (progress && isCdpClosedError(error)) throw error;
       return 0;
     }
   }
@@ -289,16 +301,19 @@ export class FrameSelectorResolver {
   async evaluateCount(
     expression: string,
     contextId: Protocol.Runtime.ExecutionContextId,
+    progress?: Progress,
   ): Promise<number> {
     const session = this.frame.session;
 
     try {
-      const evalRes = await session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
-        expression,
-        contextId,
-        returnByValue: true,
-        awaitPromise: true,
-      });
+      const evalRes = await runLocatorStep(progress, "counting elements", () =>
+        session.send<Protocol.Runtime.EvaluateResponse>("Runtime.evaluate", {
+          expression,
+          contextId,
+          returnByValue: true,
+          awaitPromise: true,
+        }),
+      );
 
       if (evalRes.exceptionDetails) {
         return 0;
@@ -308,7 +323,9 @@ export class FrameSelectorResolver {
       const num = typeof value === "number" ? value : Number(value);
       if (!Number.isFinite(num)) return 0;
       return Math.max(0, Math.floor(num));
-    } catch {
+    } catch (error) {
+      progress?.throwIfStopped();
+      if (progress && isCdpClosedError(error)) throw error;
       return 0;
     }
   }
diff --git a/packages/sdk-go/internal/extensionassets/stagehand-extension.zip b/packages/sdk-go/internal/extensionassets/stagehand-extension.zip
index 05a2974ff..c856e7373 100644
Binary files a/packages/sdk-go/internal/extensionassets/stagehand-extension.zip and b/packages/sdk-go/internal/extensionassets/stagehand-extension.zip differ