stagehand 4.4.0a0.dev1673__tar.gz → 4.4.0a0.dev1676__tar.gz

{stagehand-4.4.0a0.dev1673 → stagehand-4.4.0a0.dev1676}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stagehand
-Version: 4.4.0a0.dev1673
+Version: 4.4.0a0.dev1676
 Summary: Browserbase's SDK for building browser agents
 Keywords: ai,agent,ai-agent,browser,browser-agent,browser-automation,computer-use,headless,playwright,cdp,llm,automation,web-scraping,testing
 Author: Browserbase

{stagehand-4.4.0a0.dev1673 → stagehand-4.4.0a0.dev1676}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stagehand"
-version = "4.4.0a0.dev1673"
+version = "4.4.0a0.dev1676"
 description = "Browserbase's SDK for building browser agents"
 readme = "README.md"
 requires-python = ">=3.11"

{stagehand-4.4.0a0.dev1673 → stagehand-4.4.0a0.dev1676}/src/stagehand/_extension/manifest.json

@@ -6,7 +6,8 @@
     "debugger",
     "offscreen",
     "scripting",
-    "tabs"
+    "tabs",
+    "declarativeNetRequest"
   ],
   "host_permissions": [
     "<all_urls>"

{stagehand-4.4.0a0.dev1673 → stagehand-4.4.0a0.dev1676}/src/stagehand/_extension/service-worker.js

@@ -9206,7 +9206,7 @@ function isRecord$2(value) {
 }
 var package_default$1 = {
 	name: "@browserbasehq/stagehand-protocol",
-	version: "3.1.1-alpha-1e50db680f0429b3fb96e0519cb6d9de8c4640a5",
+	version: "3.1.1-alpha-c82e6170c29ab6fb17c4a10e44812bd29507e7d4",
 	"private": true,
 	type: "module",
 	exports: {
@@ -18454,18 +18454,6 @@ async function waitForDomNetworkQuiet(frame, logger, timeout, progress) {
 	if (remainingBudget === 0) return;
 	await progress.run("enabling network events", () => client.send("Network.enable").catch(() => {}));
 	await progress.run("enabling page events", () => client.send("Page.enable").catch(() => {}));
-	await progress.run("attaching to frames", () => client.send("Target.setAutoAttach", {
-		autoAttach: true,
-		waitForDebuggerOnStart: false,
-		flatten: true,
-		filter: [{
-			type: "worker",
-			exclude: true
-		}, {
-			type: "shared_worker",
-			exclude: true
-		}]
-	}).catch(() => {}));
 	progress.throwIfStopped();
 	await new Promise((resolve) => {
 		const inflight = /* @__PURE__ */ new Set();
@@ -66131,7 +66119,7 @@ var WebTracerProvider = class extends BasicTracerProvider {
 };
 var package_default = {
 	name: "@browserbasehq/stagehand-extension",
-	version: "1.3.0-alpha-1e50db680f0429b3fb96e0519cb6d9de8c4640a5",
+	version: "1.3.0-alpha-c82e6170c29ab6fb17c4a10e44812bd29507e7d4",
 	"private": true,
 	type: "module",
 	scripts: {
@@ -70124,6 +70112,7 @@ var StagehandRuntime = class {
 		this.state = createStore()(() => StagehandRuntimeStateSchema.parse({ status: "idle" }));
 		this.pagesById = /* @__PURE__ */ new Map();
 		this.pageEventSubscriptions = /* @__PURE__ */ new Map();
+		this.pendingBrowserSessionCleanup = /* @__PURE__ */ new Map();
 		this.browserConnectionGeneration = 0;
 		this.initializationInProgress = false;
 		this.lifecycleTail = Promise.resolve();
@@ -70134,39 +70123,49 @@ var StagehandRuntime = class {
 	async replaceBrowserConnection(params, bootstrapLogger) {
 		const { cdpUrl } = params;
 		const generation = ++this.browserConnectionGeneration;
-		const previousSession = this.browserSession;
+		if (this.browserSession && !this.pendingBrowserSessionCleanup.has(this.browserSession)) this.pendingBrowserSessionCleanup.set(this.browserSession, void 0);
 		this.browserSession = void 0;
 		this.browserSessionCdpUrl = void 0;
 		this.disposeAllPageEventSubscriptions();
 		this.pagesById.clear();
 		this.responseHandles.clear();
-		await previousSession?.close();
-		try {
-			const session = await this.adapters.browserSessionFactory(cdpUrl, this.logger, bootstrapLogger);
-			if (generation !== this.browserConnectionGeneration) {
-				await session.close();
-				throw new Error("Stagehand browser connection was dropped while connecting");
-			}
-			this.browserSession = session;
-			this.browserSessionCdpUrl = cdpUrl;
-		} catch (error) {
-			if (generation === this.browserConnectionGeneration) {
-				await this.browserSession?.close();
-				this.browserSession = void 0;
-			}
-			throw error;
+		await this.runPendingSessionCleanup();
+		if (generation !== this.browserConnectionGeneration) throw new Error("Stagehand browser connection was dropped while connecting");
+		const session = await this.adapters.browserSessionFactory(cdpUrl, this.logger, bootstrapLogger);
+		if (generation !== this.browserConnectionGeneration) {
+			await this.cleanupSession(session);
+			throw new Error("Stagehand browser connection was dropped while connecting");
 		}
+		this.browserSession = session;
+		this.browserSessionCdpUrl = cdpUrl;
 	}
 	/**
 	* Closes the runtime's own browser connection immediately, outside the lifecycle
 	* queue: a lost client must not wait behind lifecycle work that needs that client.
 	*/
-	async dropBrowserConnection() {
+	async disconnectBrowser() {
 		this.browserConnectionGeneration += 1;
-		const session = this.browserSession;
+		if (this.browserSession && !this.pendingBrowserSessionCleanup.has(this.browserSession)) this.pendingBrowserSessionCleanup.set(this.browserSession, void 0);
 		this.browserSession = void 0;
 		this.browserSessionCdpUrl = void 0;
-		await session?.close();
+		await this.runPendingSessionCleanup();
+	}
+	cleanupSession(session) {
+		const pending = this.pendingBrowserSessionCleanup.get(session);
+		if (pending) return pending;
+		const closing = Promise.resolve().then(() => session.close()).then(() => {
+			this.pendingBrowserSessionCleanup.delete(session);
+		}, (error) => {
+			this.pendingBrowserSessionCleanup.set(session, void 0);
+			throw error;
+		});
+		this.pendingBrowserSessionCleanup.set(session, closing);
+		return closing;
+	}
+	async runPendingSessionCleanup() {
+		const errors = (await Promise.allSettled(Array.from(this.pendingBrowserSessionCleanup.keys(), (session) => this.cleanupSession(session)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Browser session cleanup failed");
 	}
 	async ensureBrowserConnection(cdpUrl) {
 		if (!this.browserSession?.connected || this.browserSessionCdpUrl !== cdpUrl) await this.replaceBrowserConnection({ cdpUrl });
@@ -70582,11 +70581,9 @@ var StagehandRuntime = class {
 	}
 	async close() {
 		await this.enqueueLifecycle(async () => {
-			const session = this.browserSession;
-			this.browserSession = void 0;
-			this.browserSessionCdpUrl = void 0;
 			this.clearStagehandInstance();
-			await session?.close();
+			await this.disconnectBrowser();
+			if (!this.stagehandInstanceDisposal) this.stagehandInstanceClosing = false;
 		});
 	}
 	async disposeStagehandInstance() {
@@ -70595,10 +70592,13 @@ var StagehandRuntime = class {
 		const disposal = this.enqueueLifecycle(async () => {
 			this.disposeAllPageEventSubscriptions();
 			await this.waitForStagehandInstanceRequests();
+			const session = this.browserSession;
+			if (session?.getDomainPolicy()) await session.setDomainPolicy(null);
+			await this.runPendingSessionCleanup();
 			this.clearStagehandInstance();
+			this.stagehandInstanceClosing = false;
 		});
 		this.stagehandInstanceDisposal = disposal.finally(() => {
-			this.stagehandInstanceClosing = false;
 			this.stagehandInstanceDisposal = void 0;
 		});
 		return await this.stagehandInstanceDisposal;
@@ -71042,7 +71042,6 @@ function cookieMatchesFilter(cookie, options) {
 //#endregion
 //#region understudy/domainPolicy.ts
 var DOMAIN_LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
-var HTTP_SCHEMES = ["http", "https"];
 function canonicalizeHostname(hostname) {
 	return hostname.toLowerCase().replace(/\.+$/, "");
 }
@@ -71095,30 +71094,6 @@ function getDomainPatterns(policy, key) {
 function patternHost(rule) {
 	return rule.type === "wildcard" ? `*.${rule.hostname}` : rule.hostname;
 }
-function fetchPatternHosts(rule) {
-	const host = patternHost(rule);
-	return [host, `${host}.`];
-}
-function toBlocklistFetchPatterns(rules) {
-	const patterns = [];
-	for (const rule of rules) for (const host of fetchPatternHosts(rule)) for (const scheme of HTTP_SCHEMES) {
-		patterns.push({
-			urlPattern: `${scheme}://${host}/*`,
-			requestStage: "Request"
-		});
-		patterns.push({
-			urlPattern: `${scheme}://${host}:*/*`,
-			requestStage: "Request"
-		});
-	}
-	return patterns;
-}
-function toAllowlistFetchPatterns() {
-	return HTTP_SCHEMES.map((scheme) => ({
-		urlPattern: `${scheme}://*/*`,
-		requestStage: "Request"
-	}));
-}
 function normalizeDomainPolicy(policy) {
 	const allowedDomains = getDomainPatterns(policy, "allowedDomains");
 	const blockedDomains = getDomainPatterns(policy, "blockedDomains");
@@ -71129,8 +71104,7 @@ function normalizeDomainPolicy(policy) {
 		allowedDomains: allowedDomainRules.map(patternHost),
 		blockedDomains: blockedDomainRules.map(patternHost),
 		allowedDomainRules,
-		blockedDomainRules,
-		fetchPatterns: allowedDomainRules.length ? toAllowlistFetchPatterns() : toBlocklistFetchPatterns(blockedDomainRules)
+		blockedDomainRules
 	};
 }
 function hostnameFromHttpUrl(url) {
@@ -71162,6 +71136,53 @@ function getDomainPolicyDecision(url, policy) {
 	};
 	return { action: "continue" };
 }
+/**
+* Compile a normalized policy into browser-wide DNR session rules without installing them.
+* IDs are deterministic within this rule set; the installer must own their namespace.
+* Chrome rule limits and regex support must be checked by the installer before activation.
+*/
+function toDomainPolicyDnrRules(policy) {
+	if (!policy) return [];
+	const rules = [];
+	const addRule = (type, priority, regexFilter) => {
+		rules.push({
+			id: rules.length + 1,
+			priority,
+			action: { type },
+			condition: {
+				regexFilter,
+				isUrlFilterCaseSensitive: false,
+				resourceTypes: [
+					"main_frame",
+					"sub_frame",
+					"stylesheet",
+					"script",
+					"image",
+					"font",
+					"object",
+					"xmlhttprequest",
+					"ping",
+					"csp_report",
+					"media",
+					"websocket",
+					"webtransport",
+					"webbundle",
+					"other"
+				]
+			}
+		});
+	};
+	if (policy.allowedDomainRules.length) {
+		addRule("block", 1, "^https?://");
+		for (const rule of policy.allowedDomainRules) addRule("allow", 2, domainRuleDnrRegex(rule));
+	}
+	for (const rule of policy.blockedDomainRules) addRule("block", 3, domainRuleDnrRegex(rule));
+	return rules;
+}
+function domainRuleDnrRegex(rule) {
+	const hostname = rule.hostname.replace(/\./g, "\\.");
+	return `^https?://([^/?#@]*@)?${rule.type === "wildcard" ? "[^/?#@:]*\\." : ""}${hostname}\\.*(:[0-9]+)?(/|$)`;
+}
 var RequestSchema = discriminatedUnion("action", [strictObject({
 	action: literal("attach"),
 	targetId: string().min(1),
@@ -71293,7 +71314,7 @@ var DEFAULT_ACTIVE_PAGE_TIMEOUT_MS = 3e3;
 * so Page can record the correct owner at event time.
 */
 var BrowserContext = class BrowserContext {
-	constructor(conn, logger, chromeTabs, env = "LOCAL", localBrowserLaunchOptions = null, blankPageUrl = "about:blank", fallbackLocatorScriptSource = null) {
+	constructor(conn, logger, chromeTabs, env = "LOCAL", localBrowserLaunchOptions = null, blankPageUrl = "about:blank", fallbackLocatorScriptSource = null, domainPolicyRules) {
 		this.conn = conn;
 		this.logger = logger;
 		this.chromeTabs = chromeTabs;
@@ -71301,8 +71322,8 @@ var BrowserContext = class BrowserContext {
 		this.localBrowserLaunchOptions = localBrowserLaunchOptions;
 		this.blankPageUrl = blankPageUrl;
 		this.fallbackLocatorScriptSource = fallbackLocatorScriptSource;
+		this.domainPolicyRules = domainPolicyRules;
 		this._targetSessionListeners = /* @__PURE__ */ new Set();
-		this._domainPolicySessionListeners = /* @__PURE__ */ new Map();
 		this._sessionInit = /* @__PURE__ */ new Set();
 		this.pagesByTarget = /* @__PURE__ */ new Map();
 		this.mainFrameToTarget = /* @__PURE__ */ new Map();
@@ -71322,6 +71343,8 @@ var BrowserContext = class BrowserContext {
 		this.initScripts = [];
 		this.extraHttpHeaders = null;
 		this.domainPolicy = null;
+		this.domainPolicyTail = Promise.resolve();
+		this.closing = false;
 	}
 	get connected() {
 		return this.conn.connected;
@@ -71350,13 +71373,22 @@ var BrowserContext = class BrowserContext {
 	static async create(wsUrl, opts) {
 		const connectTask = async () => {
 			const conn = await CdpConnection.connect(wsUrl, opts.websocketFactory, opts.logger);
-			const ctx = new BrowserContext(conn, opts.logger, opts.chromeTabs, opts?.env ?? "LOCAL", opts?.localBrowserLaunchOptions ?? null, opts.blankPageUrl, opts.fallbackLocatorScriptSource);
+			const ctx = new BrowserContext(conn, opts.logger, opts.chromeTabs, opts?.env ?? "LOCAL", opts?.localBrowserLaunchOptions ?? null, opts.blankPageUrl, opts.fallbackLocatorScriptSource, opts.domainPolicyRules);
 			const bootstrap = async () => {
 				await ctx.bootstrap();
 				if (!ctx.hasTopLevelPage()) await ctx.newPage();
 			};
-			if (opts.bootstrapLogger) await conn.runWithTelemetryContext(Symbol("browser.bootstrap"), opts.bootstrapLogger, bootstrap);
-			else await bootstrap();
+			try {
+				if (opts.bootstrapLogger) await conn.runWithTelemetryContext(Symbol("browser.bootstrap"), opts.bootstrapLogger, bootstrap);
+				else await bootstrap();
+			} catch (error) {
+				try {
+					await ctx.close();
+				} catch (cleanupError) {
+					throw new AggregateError([error, cleanupError], "Browser context initialization and cleanup failed");
+				}
+				throw error;
+			}
 			return ctx;
 		};
 		return await connectTask();
@@ -71456,96 +71488,16 @@ var BrowserContext = class BrowserContext {
 	}
 	async setDomainPolicy(policy) {
 		const nextPolicy = normalizeDomainPolicy(policy);
-		this.domainPolicy = nextPolicy;
-		const sessions = [];
-		for (const sessionId of this._sessionInit) {
-			const session = this.conn.getSession(sessionId);
-			if (session) sessions.push(session);
-		}
-		if (!sessions.length) return;
-		const failures = (await Promise.allSettled(sessions.map(async (session) => {
-			if (!nextPolicy) {
-				try {
-					await session.send("Fetch.disable");
-					this.uninstallDomainPolicyHandler(session);
-				} catch (error) {
-					throw {
-						action: "disable",
-						error
-					};
-				}
-				return;
-			}
-			this.installDomainPolicyHandler(session);
-			try {
-				await session.send("Fetch.enable", { patterns: nextPolicy.fetchPatterns });
-			} catch (error) {
-				throw {
-					action: "enable",
-					error
-				};
-			}
-		}))).map((result, index) => ({
-			result,
-			session: sessions[index]
-		})).filter((entry) => entry.result.status === "rejected").map((entry) => {
-			const failure = entry.result.reason;
-			if (failure?.action === "enable") this.uninstallDomainPolicyHandler(entry.session);
-			const reason = failure?.error ?? entry.result.reason;
-			return {
-				reason,
-				sessionId: entry.session.id ?? "unknown",
-				message: reason instanceof Error ? reason.message : String(reason)
-			};
+		if (this.closing) throw new Error("Browser context is closing");
+		const rules = this.domainPolicyRules;
+		if (!rules) throw new Error("Domain policy DNR enforcement is unavailable");
+		const update = this.domainPolicyTail.then(async () => {
+			if (this.closing) throw new Error("Browser context is closing");
+			await rules.replace(nextPolicy);
+			this.domainPolicy = nextPolicy;
 		});
-		if (failures.length) {
-			this.logger.error("setDomainPolicy failed for one or more sessions", {
-				category: "ctx",
-				failures: failures.map(({ sessionId, message }) => ({
-					sessionId,
-					message
-				}))
-			});
-			throw failures[0].reason;
-		}
-	}
-	installDomainPolicyHandler(session) {
-		const sessionId = session.id;
-		if (!sessionId) return;
-		if (this._domainPolicySessionListeners.has(sessionId)) return;
-		const handler = (evt) => {
-			this.handleDomainPolicyRequestPaused(session, evt);
-		};
-		this._domainPolicySessionListeners.set(sessionId, handler);
-		session.on("Fetch.requestPaused", handler);
-	}
-	uninstallDomainPolicyHandler(session) {
-		const sessionId = session.id;
-		if (!sessionId) return;
-		const handler = this._domainPolicySessionListeners.get(sessionId);
-		if (!handler) return;
-		session.off("Fetch.requestPaused", handler);
-		this._domainPolicySessionListeners.delete(sessionId);
-	}
-	async handleDomainPolicyRequestPaused(session, evt) {
-		const decision = getDomainPolicyDecision(evt.request.url, this.domainPolicy);
-		if (decision.action === "continue") {
-			await session.send("Fetch.continueRequest", { requestId: evt.requestId }).catch(() => {});
-			return;
-		}
-		let hostname = "";
-		try {
-			hostname = new URL(evt.request.url).hostname.toLowerCase();
-		} catch {}
-		this.logger.debug("Blocked request by domain policy", {
-			category: "network",
-			hostname,
-			ruleType: decision.reason
-		});
-		await session.send("Fetch.failRequest", {
-			requestId: evt.requestId,
-			errorReason: "BlockedByClient"
-		}).catch(() => {});
+		this.domainPolicyTail = update.catch(() => void 0);
+		await update;
 	}
 	get clipboard() {
 		return this._clipboard ??= new ContextClipboard({
@@ -71629,23 +71581,42 @@ var BrowserContext = class BrowserContext {
 	/**
 	* Close CDP and clear all mappings. Best-effort cleanup.
 	*/
-	async close() {
-		await this.conn.close();
-		this.pagesByTarget.clear();
-		this.mainFrameToTarget.clear();
-		this.sessionOwnerPage.clear();
-		this.frameOwnerPage.clear();
-		this.pendingOopifByMainFrame.clear();
-		this.pendingOopifParentByMainFrame.clear();
-		this.adoptedOopifSessionByFrame.clear();
-		this.createdAtByTarget.clear();
-		this.typeByTarget.clear();
-		this.pendingCreatedTargetUrl.clear();
-		this.pageCreationFailures.clear();
-		this.pendingInitialTopLevelTargets.clear();
-		this.pendingNewPageTargets.clear();
-		this.domainPolicyClosingTargets.clear();
-		this.domainPolicyClosePromises.clear();
+	close() {
+		if (this.closePromise) return this.closePromise;
+		this.closing = true;
+		const closing = Promise.resolve().then(async () => {
+			try {
+				await this.conn.close();
+			} finally {
+				await this.domainPolicyTail;
+				try {
+					await this.domainPolicyRules?.close();
+					this.domainPolicy = null;
+				} finally {
+					this.pagesByTarget.clear();
+					this.mainFrameToTarget.clear();
+					this.sessionOwnerPage.clear();
+					this.frameOwnerPage.clear();
+					this.pendingOopifByMainFrame.clear();
+					this.pendingOopifParentByMainFrame.clear();
+					this.adoptedOopifSessionByFrame.clear();
+					this.createdAtByTarget.clear();
+					this.typeByTarget.clear();
+					this.pendingCreatedTargetUrl.clear();
+					this.pageCreationFailures.clear();
+					this.pendingInitialTopLevelTargets.clear();
+					this.pendingNewPageTargets.clear();
+					this.domainPolicyClosingTargets.clear();
+					this.domainPolicyClosePromises.clear();
+					this._sessionInit.clear();
+				}
+			}
+		});
+		this.closePromise = closing.catch((error) => {
+			this.closePromise = void 0;
+			throw error;
+		});
+		return this.closePromise;
 	}
 	/**
 	* Bootstrap target lifecycle:
@@ -71724,20 +71695,6 @@ var BrowserContext = class BrowserContext {
 				response: session.send(method, params).then(() => true).catch(() => false)
 			};
 		};
-		const queueFetchEnablePreResume = (params) => {
-			let error;
-			return {
-				dispatched: this.conn.waitForSessionDispatch(sessionId, "Fetch.enable").then(() => true).catch((err) => {
-					error = err;
-					return false;
-				}),
-				response: session.send("Fetch.enable", params).then(() => true).catch((err) => {
-					error = err;
-					return false;
-				}),
-				getError: () => error
-			};
-		};
 		const initScriptOps = [];
 		const corePreResumeOps = [
 			queuePreResume("Page.enable"),
@@ -71754,11 +71711,6 @@ var BrowserContext = class BrowserContext {
 			headerPreResumeOps.push(queuePreResume("Network.enable"));
 			headerPreResumeOps.push(queuePreResume("Network.setExtraHTTPHeaders", { headers }));
 		}
-		const fetchPreResumeOps = [];
-		if (this.domainPolicy) {
-			this.installDomainPolicyHandler(session);
-			fetchPreResumeOps.push(queueFetchEnablePreResume({ patterns: this.domainPolicy.fetchPatterns }));
-		}
 		if (this.initScripts.length) for (const source of this.initScripts) initScriptOps.push(queuePreResume("Page.addScriptToEvaluateOnNewDocument", {
 			source,
 			runImmediately: true
@@ -71766,15 +71718,13 @@ var BrowserContext = class BrowserContext {
 		const preResumeDispatched = (await Promise.all([
 			...corePreResumeOps.map((op) => op.dispatched),
 			...headerPreResumeOps.map((op) => op.dispatched),
-			...fetchPreResumeOps.map((op) => op.dispatched),
 			...initScriptOps.map((op) => op.dispatched)
 		])).every(Boolean);
 		const resumeOp = queuePreResume("Runtime.runIfWaitingForDebugger");
 		const [resumedDispatched, resumedOk] = await Promise.all([resumeOp.dispatched, resumeOp.response]);
-		const [coreResults, headerResults, fetchResults, initScriptResults] = await Promise.all([
+		const [coreResults, headerResults, initScriptResults] = await Promise.all([
 			Promise.all(corePreResumeOps.map((op) => op.response)),
 			Promise.all(headerPreResumeOps.map((op) => op.response)),
-			Promise.all(fetchPreResumeOps.map((op) => op.response)),
 			Promise.all(initScriptOps.map((op) => op.response))
 		]);
 		if (!preResumeDispatched || !resumedDispatched || !resumedOk) {
@@ -71792,23 +71742,6 @@ var BrowserContext = class BrowserContext {
 			return;
 		}
 		resumed = true;
-		if (fetchPreResumeOps.length > 0 && !fetchResults.every(Boolean)) {
-			this.uninstallDomainPolicyHandler(session);
-			const fetchError = fetchPreResumeOps.map((op) => op.getError()).find((error) => error !== void 0);
-			const fetchErrorMessage = fetchError ? fetchError instanceof Error ? fetchError.message : String(fetchError) : "Fetch.enable failed during target attach";
-			const policyFailureMessage = "Fetch.enable failed during target attach; closing target because Stagehand cannot guarantee domain policy enforcement";
-			this.recordPageCreationFailure(info.targetId, fetchError instanceof Error ? fetchError : /* @__PURE__ */ new Error(`${policyFailureMessage}: ${fetchErrorMessage}`), policyFailureMessage);
-			this.logger.error("Closing target because domain policy could not be guaranteed", {
-				category: "ctx",
-				targetId: String(info.targetId),
-				targetType: String(info.type),
-				targetUrl: String(info.url ?? ""),
-				sessionId,
-				cdpError: fetchErrorMessage
-			});
-			await this.conn.send("Target.closeTarget", { targetId: info.targetId }).catch(() => {});
-			return;
-		}
 		const scriptsInstalled = coreResults.every(Boolean) && initScriptResults.every(Boolean);
 		try {
 			session.send("Page.setLifecycleEventsEnabled", { enabled: true }).catch(() => {});
@@ -71935,7 +71868,7 @@ var BrowserContext = class BrowserContext {
 		if (existingClose) return source === "attached" ? await existingClose : true;
 		const decision = getDomainPolicyDecision(info.url ?? "", this.domainPolicy);
 		if (decision.action === "continue") return false;
-		this.logger.debug("Popup reached a disallowed domain before it could be intercepted; closing it", {
+		this.logger.debug("Closing popup targeting a disallowed domain", {
 			category: "network",
 			targetId: String(info.targetId),
 			targetUrl: String(info.url ?? ""),
@@ -71986,9 +71919,6 @@ var BrowserContext = class BrowserContext {
 		for (const [fid, sid] of Array.from(this.pendingOopifByMainFrame.entries())) if (sid === sessionId) this.removePendingOopif(fid);
 		for (const [fid, sid] of Array.from(this.adoptedOopifSessionByFrame.entries())) if (sid === sessionId) this.adoptedOopifSessionByFrame.delete(fid);
 		this._targetSessionListeners.delete(sessionId);
-		const session = this.conn.getSession(sessionId);
-		if (session) this.uninstallDomainPolicyHandler(session);
-		else this._domainPolicySessionListeners.delete(sessionId);
 		this._sessionInit.delete(sessionId);
 	}
 	/**
@@ -72122,6 +72052,95 @@ var BrowserContext = class BrowserContext {
 	}
 };
 //#endregion
+//#region understudy/domainPolicyDnr.ts
+var DOMAIN_POLICY_RULE_ID_START = 1e6;
+var DOMAIN_POLICY_RULE_ID_END = 101e4;
+function isDomainPolicyRule(rule) {
+	return rule.id >= 1e6 && rule.id < DOMAIN_POLICY_RULE_ID_END;
+}
+/** One manager per extension, with one active browser session at a time. */
+var DomainPolicyDnrManager = class {
+	constructor(api, extensionId) {
+		this.api = api;
+		this.extensionId = extensionId;
+		this.tail = Promise.resolve();
+	}
+	openSession() {
+		return this.enqueue(async () => {
+			await this.replaceRules([]);
+			const owner = Symbol("domain-policy");
+			this.owner = owner;
+			return {
+				replace: (policy) => {
+					const rules = this.compile(policy);
+					return this.enqueue(async () => {
+						if (this.owner !== owner) throw new Error("Domain policy session is no longer active");
+						await this.replaceRules(rules);
+					});
+				},
+				close: () => this.enqueue(async () => {
+					if (this.owner !== owner) return;
+					await this.replaceRules([]);
+					this.owner = void 0;
+				})
+			};
+		});
+	}
+	compile(policy) {
+		const rules = toDomainPolicyDnrRules(policy).map((rule) => ({
+			...rule,
+			id: DOMAIN_POLICY_RULE_ID_START + rule.id
+		}));
+		if (!rules.length) return rules;
+		rules.unshift({
+			id: DOMAIN_POLICY_RULE_ID_START,
+			priority: 4,
+			action: { type: "allow" },
+			condition: {
+				regexFilter: "^https?://",
+				isUrlFilterCaseSensitive: false,
+				excludedResourceTypes: [],
+				initiatorDomains: [this.extensionId],
+				tabIds: [-1]
+			}
+		});
+		return rules;
+	}
+	async replaceRules(rules) {
+		const existing = await this.api.getSessionRules();
+		const owned = existing.filter(isDomainPolicyRule);
+		const unrelated = existing.filter((rule) => !isDomainPolicyRule(rule));
+		if (rules.length) {
+			if (rules.some((rule) => !isDomainPolicyRule(rule)) || unrelated.length + rules.length > this.api.MAX_NUMBER_OF_SESSION_RULES) throw new Error("Domain policy exceeds Chrome's session rule limit");
+			if ([...unrelated, ...rules].filter((rule) => rule.condition.regexFilter !== void 0).length > this.api.MAX_NUMBER_OF_REGEX_RULES) throw new Error("Domain policy exceeds Chrome's regex rule limit");
+			const regexes = /* @__PURE__ */ new Map();
+			for (const { condition } of rules) {
+				if (condition.regexFilter === void 0) continue;
+				const options = {
+					regex: condition.regexFilter,
+					isCaseSensitive: condition.isUrlFilterCaseSensitive ?? false,
+					requireCapturing: false
+				};
+				regexes.set(JSON.stringify(options), options);
+			}
+			await Promise.all(Array.from(regexes.values(), async (options) => {
+				const result = await this.api.isRegexSupported(options);
+				if (!result.isSupported) throw new Error("Chrome does not support a domain policy regex: " + (result.reason ?? "unknown reason"));
+			}));
+		}
+		if (!owned.length && !rules.length) return;
+		await this.api.updateSessionRules({
+			removeRuleIds: owned.map((rule) => rule.id),
+			addRules: rules
+		});
+	}
+	enqueue(work) {
+		const result = this.tail.then(work, work);
+		this.tail = result.catch(() => void 0);
+		return result;
+	}
+};
+//#endregion
 //#region version.ts
 var STAGEHAND_RUNTIME_VERSION = package_default.version;
 //#endregion
@@ -72129,18 +72148,31 @@ var STAGEHAND_RUNTIME_VERSION = package_default.version;
 function startStagehandServiceWorker(scope = globalThis, runtime) {
 	const chromeRuntimeClient = new ChromeRuntimeClient(scope, STAGEHAND_SEND_TO_HOST_BINDING);
 	let rpcClient;
+	let domainPolicyManager;
 	const activeRuntime = runtime ?? createStagehandRuntime({
 		browserSessionFactory: async (cdpUrl, logger, bootstrapLogger) => {
-			const locatorRuntimeResponse = await fetch(chrome.runtime.getURL("content-script.js"));
-			if (!locatorRuntimeResponse.ok) throw new Error(`Failed to load Stagehand locator runtime: ${locatorRuntimeResponse.status}`);
-			return BrowserContext.create(cdpUrl, {
-				websocketFactory: browserWebSocketFactory,
-				logger,
-				blankPageUrl: chrome.runtime.getURL("blank.html"),
-				fallbackLocatorScriptSource: await locatorRuntimeResponse.text(),
-				chromeTabs: new ChromeTabTargetAdapter(chrome),
-				bootstrapLogger
-			});
+			domainPolicyManager ??= new DomainPolicyDnrManager(chrome.declarativeNetRequest, chrome.runtime.id);
+			const domainPolicyRules = await domainPolicyManager.openSession();
+			try {
+				const locatorRuntimeResponse = await fetch(chrome.runtime.getURL("content-script.js"));
+				if (!locatorRuntimeResponse.ok) throw new Error(`Failed to load Stagehand locator runtime: ${locatorRuntimeResponse.status}`);
+				return await BrowserContext.create(cdpUrl, {
+					websocketFactory: browserWebSocketFactory,
+					logger,
+					blankPageUrl: chrome.runtime.getURL("blank.html"),
+					fallbackLocatorScriptSource: await locatorRuntimeResponse.text(),
+					chromeTabs: new ChromeTabTargetAdapter(chrome),
+					bootstrapLogger,
+					domainPolicyRules
+				});
+			} catch (error) {
+				try {
+					await domainPolicyRules.close();
+				} catch (cleanupError) {
+					throw new AggregateError([error, cleanupError], "Browser session initialization and domain policy cleanup failed");
+				}
+				throw error;
+			}
 		},
 		emitLog: (log) => {
 			rpcClient?.notify(StagehandNotifications.log, log).catch((error) => {
@@ -72175,7 +72207,7 @@ function startStagehandServiceWorker(scope = globalThis, runtime) {
 			return session.conn;
 		},
 		rejectClientCallbacks: () => rpcClient?.releaseClient(),
-		closeConnection: () => activeRuntime.dropBrowserConnection(),
+		closeConnection: () => activeRuntime.disconnectBrowser(),
 		disposeClient: () => activeRuntime.disposeStagehandInstance(),
 		onError: (error) => {
 			console.error("Stagehand client lifecycle cleanup failed", error);

{stagehand-4.4.0a0.dev1673 → stagehand-4.4.0a0.dev1676}/src/stagehand/_generated/protocol_version.py

@@ -1,4 +1,4 @@
 """Generated from packages/protocol/package.json. Do not edit."""
 
 PROTOCOL_SEMVER_PATTERN = '^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$'
-STAGEHAND_PROTOCOL_VERSION = '3.1.1-alpha-1e50db680f0429b3fb96e0519cb6d9de8c4640a5'
+STAGEHAND_PROTOCOL_VERSION = '3.1.1-alpha-c82e6170c29ab6fb17c4a10e44812bd29507e7d4'