@orkestrel/browser 0.0.2 → 0.0.5

package/dist/src/core/index.js

@@ -45,7 +45,7 @@ var BROWSER_RESULT_LIMIT_SENTINEL_PREFIX = "[[ORKESTREL_BROWSER_RESULT_LIMIT]]";
 * throw is recognized only at the message START, not wherever the substring
 * happens to occur.
 */
-var BROWSER_RESULT_LIMIT_PATTERN = new RegExp(`(?:Uncaught )?Error: \\[\\[ORKESTREL_BROWSER_RESULT_LIMIT\\]\\](\\d+)`);
+var BROWSER_RESULT_LIMIT_PATTERN = new RegExp(`^(?:Uncaught )?Error: \\[\\[ORKESTREL_BROWSER_RESULT_LIMIT\\]\\](\\d+)`);
 /** Poll interval in milliseconds while waiting for a selector to appear. */
 var BROWSER_WAIT_POLL_INTERVAL_MS = 100;
 /**
@@ -496,9 +496,11 @@ var CDPClient = class {
 	#subscriptions = /* @__PURE__ */ new Map();
 	#sessionSubscriptions = /* @__PURE__ */ new Map();
 	#connected = false;
+	#active = false;
 	#wired = false;
 	#timeout;
 	#connecting;
+	#closing;
 	#closeRequested = false;
 	constructor(options) {
 		this.#transport = options.transport;
@@ -508,29 +510,16 @@ var CDPClient = class {
 		return this.#connected;
 	}
 	async connect() {
+		if (this.#closing !== void 0) await this.#closing;
 		if (this.#connected) return;
 		if (this.#connecting !== void 0) return this.#connecting;
 		this.#closeRequested = false;
-		const attempt = (async () => {
-			if (!this.#wired) {
-				this.#transport.emitter.on("message", (data) => this.#onMessage(data));
-				this.#transport.emitter.on("close", () => this.#onClose());
-				this.#transport.emitter.on("error", (error) => this.#onError(error));
-				this.#wired = true;
-			}
-			await this.#transport.start();
-			if (this.#closeRequested) {
-				this.#closeRequested = false;
-				await this.#transport.close();
-				throw new CDPConnectionError("CDP client was closed while connecting", { method: "connect" });
-			}
-			this.#connected = true;
-		})();
+		const attempt = this.#start();
 		this.#connecting = attempt;
 		try {
 			await attempt;
 		} finally {
-			this.#connecting = void 0;
+			if (this.#connecting === attempt) this.#connecting = void 0;
 		}
 	}
 	/**
@@ -632,18 +621,56 @@ var CDPClient = class {
 	* transport is closed deterministically once `start()` resolves.
 	*/
 	async close() {
+		const active = this.#closing;
+		if (active !== void 0) {
+			await active;
+			return;
+		}
+		const attempt = this.#stop();
+		this.#closing = attempt;
+		try {
+			await attempt;
+		} finally {
+			if (this.#closing === attempt) this.#closing = void 0;
+		}
+	}
+	async #start() {
+		if (!this.#wired) {
+			this.#transport.emitter.on("message", (data) => this.#onMessage(data));
+			this.#transport.emitter.on("close", () => this.#onClose());
+			this.#transport.emitter.on("error", (error) => this.#onError(error));
+			this.#wired = true;
+		}
+		await this.#transport.start();
+		this.#active = true;
+		if (this.#closeRequested) {
+			this.#closeRequested = false;
+			try {
+				await this.#transport.close();
+			} finally {
+				this.#active = false;
+			}
+			throw new CDPConnectionError("CDP client was closed while connecting", { method: "connect" });
+		}
+		this.#connected = true;
+	}
+	async #stop() {
 		if (this.#connecting !== void 0) {
 			this.#closeRequested = true;
 			await this.#connecting.catch(() => void 0);
 		}
-		if (!this.#connected) return;
+		if (!this.#connected && !this.#active) return;
 		this.#connected = false;
 		for (const [id, entry] of this.#pending) {
 			clearTimeout(entry.timer);
 			entry.reject(new CDPConnectionError("CDP connection closed", { method: entry.method }));
 			this.#pending.delete(id);
 		}
-		await this.#transport.close();
+		try {
+			await this.#transport.close();
+		} finally {
+			this.#active = false;
+		}
 	}
 	#nextId() {
 		this.#messageId += 1;
@@ -651,6 +678,7 @@ var CDPClient = class {
 	}
 	#onClose() {
 		this.#connected = false;
+		this.#active = false;
 		for (const [id, entry] of this.#pending) {
 			clearTimeout(entry.timer);
 			entry.reject(new CDPConnectionError("CDP connection closed", { method: entry.method }));
@@ -658,7 +686,8 @@ var CDPClient = class {
 		}
 	}
 	#onError(error) {
-		if (!this.#connected) for (const [id, entry] of this.#pending) {
+		this.#connected = false;
+		for (const [id, entry] of this.#pending) {
 			clearTimeout(entry.timer);
 			entry.reject(new CDPConnectionError(`CDP connection failed: ${String(error)}`, {
 				method: entry.method,
@@ -698,17 +727,22 @@ var CDPClient = class {
 			const rawParams = parsed["params"];
 			const params = isRecord(rawParams) ? rawParams : Object.freeze({});
 			const globalHandlers = this.#subscriptions.get(method);
-			if (globalHandlers !== void 0) for (const handler of [...globalHandlers]) handler(params);
+			if (globalHandlers !== void 0) this.#dispatch(globalHandlers, params);
 			const eventSessionId = parsed["sessionId"];
 			if (isString(eventSessionId)) {
 				const sessionMap = this.#sessionSubscriptions.get(eventSessionId);
 				if (sessionMap !== void 0) {
 					const sessionHandlers = sessionMap.get(method);
-					if (sessionHandlers !== void 0) for (const handler of [...sessionHandlers]) handler(params);
+					if (sessionHandlers !== void 0) this.#dispatch(sessionHandlers, params);
 				}
 			}
 		}
 	}
+	#dispatch(handlers, params) {
+		for (const handler of [...handlers]) try {
+			handler(params);
+		} catch {}
+	}
 };
 //#endregion
 //#region src/core/BrowserCodegen.ts
@@ -718,11 +752,17 @@ var BrowserCodegen = class {
 	#actions = [];
 	#started = false;
 	#destroyed = false;
+	#starting;
+	#stopping;
+	#shutdown;
 	#emitter;
 	constructor(client, sessionId, options) {
 		this.#client = client;
 		this.#sessionId = sessionId;
-		this.#emitter = new Emitter({ on: options?.on });
+		this.#emitter = new Emitter({
+			on: options?.on,
+			error: options?.error
+		});
 	}
 	get emitter() {
 		return this.#emitter;
@@ -731,9 +771,56 @@ var BrowserCodegen = class {
 		return this.#started;
 	}
 	async start() {
+		if (this.#destroyed) return;
+		if (this.#stopping !== void 0) await this.#stopping;
 		if (this.#destroyed) return;
 		if (this.#started) return;
-		this.#started = true;
+		const active = this.#starting;
+		if (active !== void 0) {
+			await active;
+			return;
+		}
+		const attempt = this.#begin();
+		this.#starting = attempt;
+		try {
+			await attempt;
+		} finally {
+			if (this.#starting === attempt) this.#starting = void 0;
+		}
+	}
+	async stop() {
+		await this.#starting?.catch(() => void 0);
+		if (!this.#started) return this.actions();
+		const active = this.#stopping;
+		if (active !== void 0) return await active;
+		const attempt = this.#end();
+		this.#stopping = attempt;
+		try {
+			return await attempt;
+		} finally {
+			if (this.#stopping === attempt) this.#stopping = void 0;
+		}
+	}
+	actions() {
+		return normalizeCodegenActions(this.#actions);
+	}
+	script(options) {
+		return compileCodegenScript(this.actions(), options);
+	}
+	clear() {
+		this.#actions = [];
+		this.#emitter.emit("clear");
+	}
+	destroy() {
+		const active = this.#shutdown;
+		if (active !== void 0) return active;
+		if (this.#destroyed) return Promise.resolve();
+		this.#destroyed = true;
+		const shutdown = this.#destroy();
+		this.#shutdown = shutdown;
+		return shutdown;
+	}
+	async #begin() {
 		this.#client.subscribe("Runtime.bindingCalled", this.#onBindingCalled, this.#sessionId);
 		this.#client.subscribe("Page.frameNavigated", this.#onFrameNavigated, this.#sessionId);
 		try {
@@ -744,36 +831,25 @@ var BrowserCodegen = class {
 				expression: BROWSER_CODEGEN_SOURCE,
 				awaitPromise: true
 			}, this.#sessionId);
+			if (this.#destroyed) {
+				this.#unsubscribe();
+				return;
+			}
 		} catch (error) {
-			this.#client.unsubscribe("Runtime.bindingCalled", this.#onBindingCalled, this.#sessionId);
-			this.#client.unsubscribe("Page.frameNavigated", this.#onFrameNavigated, this.#sessionId);
-			this.#started = false;
+			this.#unsubscribe();
 			throw error;
 		}
+		this.#started = true;
 		this.#emitter.emit("start");
 	}
-	async stop() {
-		if (!this.#started) return this.actions();
-		this.#client.unsubscribe("Runtime.bindingCalled", this.#onBindingCalled, this.#sessionId);
-		this.#client.unsubscribe("Page.frameNavigated", this.#onFrameNavigated, this.#sessionId);
+	async #end() {
+		this.#unsubscribe();
 		this.#started = false;
 		const snapshot = this.actions();
 		this.#emitter.emit("stop", snapshot);
 		return snapshot;
 	}
-	actions() {
-		return normalizeCodegenActions(this.#actions);
-	}
-	script(options) {
-		return compileCodegenScript(this.actions(), options);
-	}
-	clear() {
-		this.#actions = [];
-		this.#emitter.emit("clear");
-	}
-	async destroy() {
-		if (this.#destroyed) return;
-		this.#destroyed = true;
+	async #destroy() {
 		try {
 			await this.stop();
 		} catch {}
@@ -793,6 +869,10 @@ var BrowserCodegen = class {
 		this.#actions.push(action);
 		this.#emitter.emit("action", action);
 	};
+	#unsubscribe() {
+		this.#client.unsubscribe("Runtime.bindingCalled", this.#onBindingCalled, this.#sessionId);
+		this.#client.unsubscribe("Page.frameNavigated", this.#onFrameNavigated, this.#sessionId);
+	}
 };
 //#endregion
 //#region src/core/BrowserPage.ts
@@ -804,16 +884,26 @@ var BrowserPage = class {
 	#url = "about:blank";
 	#closed = false;
 	#codegen;
-	#destroyHandler;
+	#codegenStart;
+	#navigation;
+	#closing;
+	#releasing;
+	#loadEvent;
+	#loadTimer;
+	#loadResolve;
+	#loadReject;
+	#destroyHandler = (params) => {
+		if (!isString(params["targetId"]) || params["targetId"] !== this.#targetId) return;
+		this.#closed = true;
+		this.#release().catch(() => void 0);
+	};
+	#loadHandler = () => this.#resolveLoad();
 	constructor(client, targetId, sessionId, writer, url) {
 		this.#client = client;
 		this.#targetId = targetId;
 		this.#sessionId = sessionId;
 		this.#writer = writer;
 		if (url !== void 0) this.#url = url;
-		this.#destroyHandler = (params) => {
-			if (isString(params["targetId"]) && params["targetId"] === this.#targetId) this.#closed = true;
-		};
 		this.#client.subscribe("Target.targetDestroyed", this.#destroyHandler);
 	}
 	get url() {
@@ -823,46 +913,41 @@ var BrowserPage = class {
 		return this.#closed;
 	}
 	async title() {
+		this.#assertOpen();
 		const result = await this.#evaluate("document.title");
-		return typeof result === "string" ? result : "";
+		return this.#requireString(result, "Document title");
 	}
 	async navigate(url, options) {
-		const timeout = options?.timeout ?? 3e4;
-		const condition = options?.condition ?? "load";
-		const wait = this.#waitForLoadEvent(condition, timeout);
-		const waitOutcome = wait.promise.then(() => ({ ok: true }), (error) => ({
-			ok: false,
-			error
-		}));
+		this.#assertOpen();
+		while (this.#navigation !== void 0) await this.#navigation.catch(() => void 0);
+		this.#assertOpen();
+		const navigation = this.#navigate(url, options);
+		this.#navigation = navigation;
 		try {
-			const result = await this.#client.send("Page.navigate", { url }, this.#sessionId, timeout);
-			if (isRecord(result) && isString(result["errorText"])) throw new BrowserError(`Navigation failed: ${result["errorText"]}`);
-			const outcome = await waitOutcome;
-			if (!outcome.ok) throw outcome.error;
-		} catch (error) {
-			wait.cancel();
-			await this.#stopLoading(Math.min(timeout, BROWSER_STOP_LOADING_TIMEOUT_MS));
-			throw error;
+			await navigation;
+		} finally {
+			if (this.#navigation === navigation) this.#navigation = void 0;
 		}
-		const currentUrl = await this.#evaluate("location.href");
-		this.#url = typeof currentUrl === "string" ? currentUrl : url;
 	}
 	async content() {
+		this.#assertOpen();
 		const [title, html, text, currentUrl] = await Promise.all([
 			this.#evaluate("document.title"),
 			this.#evaluate(guardEvaluateExpression("document.documentElement.outerHTML", BROWSER_RESULT_LIMIT)),
 			this.#evaluate(guardEvaluateExpression("document.body ? document.body.innerText : \"\"", BROWSER_RESULT_LIMIT)),
 			this.#evaluate("location.href")
 		]);
-		if (typeof currentUrl === "string") this.#url = currentUrl;
+		const url = this.#requireString(currentUrl, "Document URL");
+		this.#url = url;
 		return {
-			url: this.#url,
-			title: typeof title === "string" ? title : "",
-			html: typeof html === "string" ? html : "",
-			text: typeof text === "string" ? text : ""
+			url,
+			title: this.#requireString(title, "Document title"),
+			html: this.#requireString(html, "Document HTML"),
+			text: this.#requireString(text, "Document text")
 		};
 	}
 	async screenshot(options) {
+		this.#assertOpen();
 		const format = options?.type ?? "png";
 		const params = { format };
 		if (options?.quality !== void 0 && format === "jpeg") params["quality"] = options.quality;
@@ -870,9 +955,9 @@ var BrowserPage = class {
 			const metrics = await this.#client.send("Page.getLayoutMetrics", void 0, this.#sessionId);
 			if (isRecord(metrics) && isRecord(metrics["contentSize"])) {
 				const contentSize = metrics["contentSize"];
-				const width = typeof contentSize["width"] === "number" ? contentSize["width"] : 0;
-				const height = typeof contentSize["height"] === "number" ? contentSize["height"] : 0;
-				if (width > 0 && height > 0) {
+				const width = contentSize["width"];
+				const height = contentSize["height"];
+				if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
 					params["clip"] = {
 						x: 0,
 						y: 0,
@@ -894,11 +979,13 @@ var BrowserPage = class {
 		};
 	}
 	async click(selector, options) {
+		this.#assertOpen();
 		const timeout = options?.timeout ?? 3e4;
 		await this.#waitForSelector(selector, timeout);
 		await this.#evaluate(`(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (el) { el.scrollIntoView({ block: 'center' }); el.click(); } else { throw new Error('Element not found: ' + ${JSON.stringify(selector)}); } })()`);
 	}
 	async fill(selector, value, options) {
+		this.#assertOpen();
 		const timeout = options?.timeout ?? 3e4;
 		await this.#waitForSelector(selector, timeout);
 		await this.#evaluate(`(() => {
@@ -916,6 +1003,7 @@ var BrowserPage = class {
             })()`);
 	}
 	async select(selector, values, options) {
+		this.#assertOpen();
 		const timeout = options?.timeout ?? 3e4;
 		await this.#waitForSelector(selector, timeout);
 		const valuesJson = JSON.stringify([...values]);
@@ -930,9 +1018,11 @@ var BrowserPage = class {
             })()`);
 	}
 	async evaluate(expression) {
+		this.#assertOpen();
 		return this.#evaluate(guardEvaluateExpression(expression, BROWSER_RESULT_LIMIT));
 	}
 	async wait(selector, options) {
+		this.#assertOpen();
 		const timeout = options?.timeout ?? 3e4;
 		await this.#waitForSelector(selector, timeout);
 	}
@@ -940,6 +1030,7 @@ var BrowserPage = class {
 		return (await this.frames()).find((frame) => frame.name === name || frame.url === name);
 	}
 	async frames() {
+		this.#assertOpen();
 		const result = await this.#client.send("Page.getFrameTree", void 0, this.#sessionId);
 		if (!isRecord(result) || !isRecord(result["frameTree"])) return [];
 		const frames = [];
@@ -947,15 +1038,88 @@ var BrowserPage = class {
 		return frames;
 	}
 	async codegen(options) {
+		this.#assertOpen();
 		if (this.#codegen !== void 0) return this.#codegen;
+		const active = this.#codegenStart;
+		if (active !== void 0) return await active;
+		const attempt = this.#startCodegen(options);
+		this.#codegenStart = attempt;
+		try {
+			return await attempt;
+		} finally {
+			if (this.#codegenStart === attempt) this.#codegenStart = void 0;
+		}
+	}
+	destroy() {
+		const active = this.#closing;
+		if (active !== void 0) return active;
+		this.#closed = true;
+		const closing = this.#destroy();
+		this.#closing = closing;
+		return closing;
+	}
+	close() {
+		const active = this.#closing;
+		if (active !== void 0) return active;
+		if (this.#closed) {
+			const closing = this.#release();
+			this.#closing = closing;
+			return closing;
+		}
+		this.#closed = true;
+		const closing = this.#close();
+		this.#closing = closing;
+		return closing;
+	}
+	async #navigate(url, options) {
+		const timeout = options?.timeout ?? 3e4;
+		const condition = options?.condition ?? "load";
+		const wait = this.#waitForLoadEvent(condition, timeout);
+		wait.catch(() => void 0);
+		try {
+			const result = await this.#client.send("Page.navigate", { url }, this.#sessionId, timeout);
+			if (isRecord(result) && isString(result["errorText"])) throw new BrowserError(`Navigation failed: ${result["errorText"]}`);
+			await wait;
+		} catch (error) {
+			this.#cancelLoad();
+			await this.#stopLoading(Math.min(timeout, BROWSER_STOP_LOADING_TIMEOUT_MS));
+			throw error;
+		}
+		const currentUrl = await this.#evaluate("location.href");
+		this.#url = this.#requireString(currentUrl, "Navigation URL");
+	}
+	async #startCodegen(options) {
 		const codegen = new BrowserCodegen(this.#client, this.#sessionId, options);
 		await codegen.start();
+		if (this.#closed) {
+			await codegen.destroy();
+			throw new BrowserError("Browser page is closed");
+		}
 		this.#codegen = codegen;
 		return codegen;
 	}
-	async close() {
-		if (this.#closed) return;
-		this.#closed = true;
+	async #destroy() {
+		await this.#release();
+		try {
+			await this.#client.send("Target.detachFromTarget", { sessionId: this.#sessionId });
+		} catch {}
+	}
+	async #close() {
+		await this.#release();
+		try {
+			await this.#client.send("Target.closeTarget", { targetId: this.#targetId });
+		} catch {}
+	}
+	#release() {
+		const active = this.#releasing;
+		if (active !== void 0) return active;
+		const release = this.#releaseResources();
+		this.#releasing = release;
+		return release;
+	}
+	async #releaseResources() {
+		this.#cancelLoad();
+		await this.#codegenStart?.catch(() => void 0);
 		if (this.#codegen !== void 0) {
 			try {
 				await this.#codegen.destroy();
@@ -963,9 +1127,6 @@ var BrowserPage = class {
 			this.#codegen = void 0;
 		}
 		this.#client.unsubscribe("Target.targetDestroyed", this.#destroyHandler);
-		try {
-			await this.#client.send("Target.closeTarget", { targetId: this.#targetId });
-		} catch {}
 	}
 	#flattenFrameTree(node, out) {
 		const frame = node["frame"];
@@ -1024,35 +1185,43 @@ var BrowserPage = class {
 	}
 	#waitForLoadEvent(condition, timeout) {
 		const eventName = condition === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
-		let settled = false;
-		let timer;
-		let handler;
-		const promise = new Promise((resolve, reject) => {
-			timer = setTimeout(() => {
-				if (settled) return;
-				settled = true;
-				this.#client.unsubscribe(eventName, handler, this.#sessionId);
-				reject(new BrowserError(`Navigation timeout after ${timeout}ms`));
-			}, timeout);
-			handler = () => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timer);
-				this.#client.unsubscribe(eventName, handler, this.#sessionId);
-				resolve();
-			};
-			this.#client.subscribe(eventName, handler, this.#sessionId);
-		});
-		const cancel = () => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			this.#client.unsubscribe(eventName, handler, this.#sessionId);
-		};
-		return {
-			promise,
-			cancel
-		};
+		const deferred = Promise.withResolvers();
+		this.#loadEvent = eventName;
+		this.#loadResolve = deferred.resolve;
+		this.#loadReject = deferred.reject;
+		this.#loadTimer = setTimeout(() => {
+			this.#rejectLoad(new BrowserError(`Navigation timeout after ${timeout}ms`));
+		}, timeout);
+		this.#client.subscribe(eventName, this.#loadHandler, this.#sessionId);
+		return deferred.promise;
+	}
+	#resolveLoad() {
+		const resolve = this.#loadResolve;
+		this.#clearLoad();
+		resolve?.();
+	}
+	#rejectLoad(error) {
+		const reject = this.#loadReject;
+		this.#clearLoad();
+		reject?.(error);
+	}
+	#cancelLoad() {
+		this.#rejectLoad(new BrowserError("Navigation cancelled"));
+	}
+	#clearLoad() {
+		if (this.#loadTimer !== void 0) clearTimeout(this.#loadTimer);
+		if (this.#loadEvent !== void 0) this.#client.unsubscribe(this.#loadEvent, this.#loadHandler, this.#sessionId);
+		this.#loadEvent = void 0;
+		this.#loadTimer = void 0;
+		this.#loadResolve = void 0;
+		this.#loadReject = void 0;
+	}
+	#requireString(value, field) {
+		if (typeof value === "string") return value;
+		throw new BrowserError(`${field} failed: no string value returned`);
+	}
+	#assertOpen() {
+		if (this.#closed) throw new BrowserError("Browser page is closed");
 	}
 };
 //#endregion
@@ -1063,6 +1232,10 @@ var BrowserContext = class {
 	#viewport;
 	#writer;
 	#pages = /* @__PURE__ */ new Map();
+	#creating = /* @__PURE__ */ new Set();
+	#syncing;
+	#shutdown;
+	#closed = false;
 	constructor(client, id, viewport, writer) {
 		this.#client = client;
 		this.#id = id;
@@ -1074,78 +1247,165 @@ var BrowserContext = class {
 	}
 	page(index) {
 		const i = index ?? 0;
-		const values = [...this.#pages.values()];
-		return i >= 0 && i < values.length ? values[i] : void 0;
+		const pages = [...this.#pages.values()];
+		return i >= 0 && i < pages.length ? pages[i] : void 0;
 	}
 	pages() {
 		return [...this.#pages.values()];
 	}
 	async create(options) {
-		const createParams = { url: "about:blank" };
-		if (this.#id !== void 0) createParams["browserContextId"] = this.#id;
-		const result = await this.#client.send("Target.createTarget", createParams);
-		if (!isRecord(result) || !isString(result["targetId"])) throw new Error("Failed to create new browser target");
+		if (this.#closed) throw new BrowserError("Browser context is closed");
+		const attempt = this.#create(options);
+		this.#creating.add(attempt);
+		try {
+			return await attempt;
+		} finally {
+			this.#creating.delete(attempt);
+		}
+	}
+	async sync(targets) {
+		while (this.#syncing !== void 0) await this.#syncing;
+		if (this.#closed) throw new BrowserError("Browser context is closed");
+		const attempt = this.#sync(targets);
+		this.#syncing = attempt;
+		try {
+			await attempt;
+		} finally {
+			if (this.#syncing === attempt) this.#syncing = void 0;
+		}
+	}
+	destroy() {
+		const active = this.#shutdown;
+		if (active !== void 0) return active;
+		this.#closed = true;
+		const shutdown = this.#destroyResources();
+		this.#shutdown = shutdown;
+		return shutdown;
+	}
+	close() {
+		const active = this.#shutdown;
+		if (active !== void 0) return active;
+		this.#closed = true;
+		const shutdown = this.#closeResources();
+		this.#shutdown = shutdown;
+		return shutdown;
+	}
+	async #create(options) {
+		const result = await this.#client.send("Target.createTarget", {
+			url: "about:blank",
+			...this.#id === void 0 ? {} : { browserContextId: this.#id }
+		});
+		if (!isRecord(result) || !isString(result["targetId"])) throw new BrowserError("Failed to create new browser target");
 		const targetId = result["targetId"];
-		const attachResult = await this.#client.send("Target.attachToTarget", {
+		let page;
+		try {
+			const viewport = options?.viewport ?? this.#viewport;
+			page = await this.#attach(targetId, options?.url ?? "about:blank", viewport);
+			if (options?.url !== void 0 && options.url !== "about:blank") await page.navigate(options.url, { timeout: options.timeout });
+			if (this.#closed) throw new BrowserError("Browser context closed during page creation");
+			this.#pages.set(targetId, page);
+			return page;
+		} catch (error) {
+			if (page !== void 0) await page.close();
+			else await this.#closeTarget(targetId);
+			throw error;
+		}
+	}
+	async #sync(targets) {
+		const pageTargets = targets.filter((target) => target.type === "page");
+		const targetIds = new Set(pageTargets.map((target) => target.id));
+		for (const [id, page] of this.#pages) {
+			if (targetIds.has(id)) continue;
+			await page.destroy();
+			this.#pages.delete(id);
+		}
+		for (const target of pageTargets) {
+			if (this.#closed || this.#pages.has(target.id)) continue;
+			try {
+				const page = await this.#reattach(target.id, target.url, this.#viewport);
+				if (this.#closed) {
+					await page.destroy();
+					continue;
+				}
+				this.#pages.set(target.id, page);
+			} catch {}
+		}
+	}
+	async #attach(targetId, url, viewport) {
+		let sessionId;
+		try {
+			sessionId = await this.#openSession(targetId);
+			await this.#enableSession(sessionId);
+			if (viewport !== void 0) await this.#applyViewport(sessionId, viewport);
+			return new BrowserPage(this.#client, targetId, sessionId, this.#writer, url);
+		} catch (error) {
+			if (sessionId !== void 0) await this.#detachSession(sessionId);
+			throw error;
+		}
+	}
+	async #reattach(targetId, url, viewport) {
+		let sessionId;
+		try {
+			sessionId = await this.#openSession(targetId);
+			await this.#enableSession(sessionId);
+			if (viewport !== void 0) await this.#tryViewport(sessionId, viewport);
+			return new BrowserPage(this.#client, targetId, sessionId, this.#writer, url);
+		} catch (error) {
+			if (sessionId !== void 0) await this.#detachSession(sessionId);
+			throw error;
+		}
+	}
+	async #destroyResources() {
+		await this.#settle();
+		for (const page of this.#pages.values()) await page.destroy();
+		this.#pages.clear();
+	}
+	async #closeResources() {
+		await this.#settle();
+		for (const page of this.#pages.values()) await page.close();
+		this.#pages.clear();
+		if (this.#id === void 0) return;
+		try {
+			await this.#client.send("Target.disposeBrowserContext", { browserContextId: this.#id });
+		} catch {}
+	}
+	async #settle() {
+		await Promise.allSettled([...this.#creating]);
+		await this.#syncing?.catch(() => void 0);
+	}
+	async #openSession(targetId) {
+		const result = await this.#client.send("Target.attachToTarget", {
 			targetId,
 			flatten: true
 		});
-		if (!isRecord(attachResult) || !isString(attachResult["sessionId"])) throw new Error("Failed to attach to browser target");
-		const sessionId = attachResult["sessionId"];
+		if (!isRecord(result) || !isString(result["sessionId"])) throw new BrowserError("Failed to attach to browser target");
+		return result["sessionId"];
+	}
+	async #enableSession(sessionId) {
 		await this.#client.send("Page.enable", void 0, sessionId);
 		await this.#client.send("Runtime.enable", void 0, sessionId);
-		const viewport = options?.viewport ?? this.#viewport;
-		if (viewport !== void 0) await this.#client.send("Emulation.setDeviceMetricsOverride", {
+	}
+	async #applyViewport(sessionId, viewport) {
+		await this.#client.send("Emulation.setDeviceMetricsOverride", {
 			width: viewport.width,
 			height: viewport.height,
 			deviceScaleFactor: 1,
 			mobile: false
 		}, sessionId);
-		const page = new BrowserPage(this.#client, targetId, sessionId, this.#writer, options?.url);
-		if (options?.url !== void 0 && options.url !== "about:blank") await page.navigate(options.url, { timeout: options.timeout });
-		this.#pages.set(targetId, page);
-		return page;
 	}
-	async sync(targets) {
-		const pageTargets = targets.filter((t) => t.type === "page");
-		const targetIds = new Set(pageTargets.map((t) => t.id));
-		for (const [id, page] of this.#pages) {
-			if (targetIds.has(id)) continue;
-			try {
-				await page.close();
-			} catch {}
-			this.#pages.delete(id);
-		}
-		for (const target of pageTargets) {
-			if (this.#pages.has(target.id)) continue;
-			try {
-				const attachResult = await this.#client.send("Target.attachToTarget", {
-					targetId: target.id,
-					flatten: true
-				});
-				if (!isRecord(attachResult) || !isString(attachResult["sessionId"])) continue;
-				const sessionId = attachResult["sessionId"];
-				await this.#client.send("Page.enable", void 0, sessionId);
-				await this.#client.send("Runtime.enable", void 0, sessionId);
-				if (this.#viewport !== void 0) try {
-					await this.#client.send("Emulation.setDeviceMetricsOverride", {
-						width: this.#viewport.width,
-						height: this.#viewport.height,
-						deviceScaleFactor: 1,
-						mobile: false
-					}, sessionId);
-				} catch {}
-				this.#pages.set(target.id, new BrowserPage(this.#client, target.id, sessionId, this.#writer, target.url));
-			} catch {}
-		}
+	async #tryViewport(sessionId, viewport) {
+		try {
+			await this.#applyViewport(sessionId, viewport);
+		} catch {}
 	}
-	async close() {
-		for (const page of this.#pages.values()) try {
-			await page.close();
+	async #closeTarget(targetId) {
+		try {
+			await this.#client.send("Target.closeTarget", { targetId });
 		} catch {}
-		this.#pages.clear();
-		if (this.#id !== void 0) try {
-			await this.#client.send("Target.disposeBrowserContext", { browserContextId: this.#id });
+	}
+	async #detachSession(sessionId) {
+		try {
+			await this.#client.send("Target.detachFromTarget", { sessionId });
 		} catch {}
 	}
 };